Bug 1215455 - eslint object-curly-spacing [r=Standard8]
authorEd Lee <edilee@mozilla.com>
Fri, 16 Oct 2015 01:18:11 -0700
changeset 304182 5f023c0c5fb33e4ac636d9c6d13892e377ef4e97
parent 304181 2788036d08a80b062f70832a0a75e37acccc182e
child 304183 412326380fc25f783726a4c9baa54c3d6fe78983
push id1001
push userraliiev@mozilla.com
push dateMon, 18 Jan 2016 19:06:03 +0000
treeherdermozilla-release@8b89261f3ac4 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersStandard8
bugs1215455
milestone44.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1215455 - eslint object-curly-spacing [r=Standard8]
browser/components/loop/.eslintrc
browser/components/loop/content/js/conversationAppStore.js
browser/components/loop/content/js/panel.js
browser/components/loop/content/js/panel.jsx
browser/components/loop/content/js/roomStore.js
browser/components/loop/content/js/roomViews.js
browser/components/loop/content/js/roomViews.jsx
browser/components/loop/content/shared/js/activeRoomStore.js
browser/components/loop/content/shared/js/crypto.js
browser/components/loop/content/shared/js/mixins.js
browser/components/loop/content/shared/js/models.js
browser/components/loop/content/shared/js/otSdkDriver.js
browser/components/loop/content/shared/js/textChatView.js
browser/components/loop/content/shared/js/textChatView.jsx
browser/components/loop/content/shared/js/utils.js
browser/components/loop/content/shared/js/views.js
browser/components/loop/content/shared/js/views.jsx
browser/components/loop/modules/GoogleImporter.jsm
browser/components/loop/modules/LoopContacts.jsm
browser/components/loop/modules/LoopRooms.jsm
browser/components/loop/modules/LoopRoomsCache.jsm
browser/components/loop/modules/LoopStorage.jsm
browser/components/loop/modules/MozLoopPushHandler.jsm
browser/components/loop/modules/MozLoopService.jsm
browser/components/loop/standalone/content/js/standaloneRoomViews.js
browser/components/loop/standalone/content/js/standaloneRoomViews.jsx
browser/components/loop/standalone/content/js/webapp.js
browser/components/loop/standalone/content/js/webapp.jsx
browser/components/loop/test/desktop-local/conversation_test.js
browser/components/loop/test/desktop-local/l10n_test.js
browser/components/loop/test/desktop-local/panel_test.js
browser/components/loop/test/desktop-local/roomStore_test.js
browser/components/loop/test/desktop-local/roomViews_test.js
browser/components/loop/test/mochitest/browser_CardDavImporter.js
browser/components/loop/test/mochitest/browser_GoogleImporter.js
browser/components/loop/test/mochitest/browser_LoopContacts.js
browser/components/loop/test/mochitest/browser_LoopRooms_channel.js
browser/components/loop/test/mochitest/browser_fxa_login.js
browser/components/loop/test/mochitest/browser_mozLoop_sharingListeners.js
browser/components/loop/test/mochitest/browser_mozLoop_socialShare.js
browser/components/loop/test/mochitest/browser_toolbarbutton.js
browser/components/loop/test/mochitest/head.js
browser/components/loop/test/shared/activeRoomStore_test.js
browser/components/loop/test/shared/crypto_test.js
browser/components/loop/test/shared/linkifiedTextView_test.js
browser/components/loop/test/shared/mixins_test.js
browser/components/loop/test/shared/models_test.js
browser/components/loop/test/shared/otSdkDriver_test.js
browser/components/loop/test/shared/store_test.js
browser/components/loop/test/shared/utils_test.js
browser/components/loop/test/shared/validate_test.js
browser/components/loop/test/shared/views_test.js
browser/components/loop/test/standalone/standaloneMetricsStore_test.js
browser/components/loop/test/standalone/standaloneMozLoop_test.js
browser/components/loop/test/standalone/standaloneRoomViews_test.js
browser/components/loop/test/standalone/webapp_test.js
browser/components/loop/test/xpcshell/head.js
browser/components/loop/test/xpcshell/test_looppush_initialize.js
browser/components/loop/test/xpcshell/test_looprooms_encryption_in_fxa.js
browser/components/loop/test/xpcshell/test_looprooms_upgrade_to_encryption.js
browser/components/loop/test/xpcshell/test_loopservice_dnd.js
browser/components/loop/test/xpcshell/test_loopservice_hawk_request.js
browser/components/loop/ui/ui-showcase.js
browser/components/loop/ui/ui-showcase.jsx
--- a/browser/components/loop/.eslintrc
+++ b/browser/components/loop/.eslintrc
@@ -95,17 +95,17 @@
     "no-underscore-dangle": 0,    // Leave as 0. Commonly used for private variables.
     "no-unexpected-multiline": 2,
     "no-unneeded-ternary": 2,
     "no-unused-expressions": 0,   // TODO: Set to 2
     "no-unused-vars": 0,          // TODO: Set to 2
     "no-use-before-define": 0,    // TODO: Set to 2
     "no-useless-call": 2,
     "no-with": 2,
-    "object-curly-spacing": 0,    // [2, "always"],
+    "object-curly-spacing": [2, "always"],
     "quotes": [2, "double", "avoid-escape"],
     "semi": 2,
     "semi-spacing": [2, {"before": false, "after": true}],
     "space-before-keywords": 2,
     "space-infix-ops": 2,
     "space-return-throw-case": 2,
     "space-unary-ops": [2, {"words": true, "nonwords": false}],
     "spaced-comment": [2, "always"],
--- a/browser/components/loop/content/js/conversationAppStore.js
+++ b/browser/components/loop/content/js/conversationAppStore.js
@@ -102,24 +102,24 @@ loop.store.ConversationAppStore = (funct
      *
      * @param {sharedActions.GetWindowData} actionData The action data
      */
     getWindowData: function(actionData) {
       var windowData = this._mozLoop.getConversationWindowData(actionData.windowId);
 
       if (!windowData) {
         console.error("Failed to get the window data");
-        this.setStoreState({windowType: "failed"});
+        this.setStoreState({ windowType: "failed" });
         return;
       }
 
-      this.setStoreState({windowType: windowData.type});
+      this.setStoreState({ windowType: windowData.type });
 
       this._dispatcher.dispatch(new loop.shared.actions.SetupWindowData(_.extend({
-        windowId: actionData.windowId}, windowData)));
+        windowId: actionData.windowId }, windowData)));
     },
 
     /**
      * Event handler; invoked when the 'unload' event is dispatched from the
      * window object.
      * It will dispatch a 'WindowUnload' action that other stores may listen to
      * and will remove all event handlers attached to the window object.
      */
--- a/browser/components/loop/content/js/panel.js
+++ b/browser/components/loop/content/js/panel.js
@@ -137,17 +137,17 @@ loop.panel = (function(_, mozL10n) {
       return (
         React.createElement("div", {className: "powered-by-wrapper", id: "powered-by-wrapper"}, 
           React.createElement("p", {className: "powered-by", id: "powered-by"}, 
             mozL10n.get("powered_by_beforeLogo"), 
             React.createElement("span", {className: locale, id: "powered-by-logo"}), 
             mozL10n.get("powered_by_afterLogo")
           ), 
           React.createElement("p", {className: "terms-service", 
-             dangerouslySetInnerHTML: {__html: tosHTML}, 
+             dangerouslySetInnerHTML: { __html: tosHTML}, 
              onClick: this.handleLinkClick})
          )
       );
     }
   });
 
   /**
    * Panel settings (gear) menu entry.
@@ -156,17 +156,17 @@ loop.panel = (function(_, mozL10n) {
     propTypes: {
       displayed: React.PropTypes.bool,
       extraCSSClass: React.PropTypes.string,
       label: React.PropTypes.string.isRequired,
       onClick: React.PropTypes.func.isRequired
     },
 
     getDefaultProps: function() {
-      return {displayed: true};
+      return { displayed: true };
     },
 
     render: function() {
       var cx = React.addons.classSet;
 
       if (!this.props.displayed) {
         return null;
       }
@@ -252,17 +252,17 @@ loop.panel = (function(_, mozL10n) {
                                                                  "settings_menu_item_turnnotificationsoff";
 
       return (
         React.createElement("div", {className: "settings-menu dropdown"}, 
           React.createElement("button", {className: "button-settings", 
              onClick: this.toggleDropdownMenu, 
              ref: "menu-button", 
              title: mozL10n.get("settings_menu_button_tooltip")}), 
-          React.createElement("ul", {className: cx({"dropdown-menu": true, hide: !this.state.showMenu})}, 
+          React.createElement("ul", {className: cx({ "dropdown-menu": true, hide: !this.state.showMenu })}, 
             React.createElement(SettingsDropdownEntry, {
                 extraCSSClass: "entry-settings-notifications entries-divider", 
                 label: mozL10n.get(notificationsLabel), 
                 onClick: this.handleToggleNotifications}), 
             React.createElement(SettingsDropdownEntry, {
                 displayed: this._isSignedIn() && this.props.mozLoop.fxAEnabled, 
                 extraCSSClass: "entry-settings-account", 
                 label: mozL10n.get("settings_menu_item_account"), 
@@ -854,19 +854,19 @@ loop.panel = (function(_, mozL10n) {
     },
 
     _onStatusChanged: function() {
       var profile = this.props.mozLoop.userProfile;
       var currUid = this.state.userProfile ? this.state.userProfile.uid : null;
       var newUid = profile ? profile.uid : null;
       if (currUid === newUid) {
         // Update the state of hasEncryptionKey as this might have changed now.
-        this.setState({hasEncryptionKey: this.props.mozLoop.hasEncryptionKey});
+        this.setState({ hasEncryptionKey: this.props.mozLoop.hasEncryptionKey });
       } else {
-        this.setState({userProfile: profile});
+        this.setState({ userProfile: profile });
       }
       this.updateServiceErrors();
     },
 
     _gettingStartedSeen: function() {
       this.setState({
         gettingStartedSeen: this.props.mozLoop.getLoopPref("gettingStarted.seen")
       });
--- a/browser/components/loop/content/js/panel.jsx
+++ b/browser/components/loop/content/js/panel.jsx
@@ -137,17 +137,17 @@ loop.panel = (function(_, mozL10n) {
       return (
         <div className="powered-by-wrapper" id="powered-by-wrapper">
           <p className="powered-by" id="powered-by">
             {mozL10n.get("powered_by_beforeLogo")}
             <span className={locale} id="powered-by-logo"/>
             {mozL10n.get("powered_by_afterLogo")}
           </p>
           <p className="terms-service"
-             dangerouslySetInnerHTML={{__html: tosHTML}}
+             dangerouslySetInnerHTML={{ __html: tosHTML }}
              onClick={this.handleLinkClick}></p>
          </div>
       );
     }
   });
 
   /**
    * Panel settings (gear) menu entry.
@@ -156,17 +156,17 @@ loop.panel = (function(_, mozL10n) {
     propTypes: {
       displayed: React.PropTypes.bool,
       extraCSSClass: React.PropTypes.string,
       label: React.PropTypes.string.isRequired,
       onClick: React.PropTypes.func.isRequired
     },
 
     getDefaultProps: function() {
-      return {displayed: true};
+      return { displayed: true };
     },
 
     render: function() {
       var cx = React.addons.classSet;
 
       if (!this.props.displayed) {
         return null;
       }
@@ -252,17 +252,17 @@ loop.panel = (function(_, mozL10n) {
                                                                  "settings_menu_item_turnnotificationsoff";
 
       return (
         <div className="settings-menu dropdown">
           <button className="button-settings"
              onClick={this.toggleDropdownMenu}
              ref="menu-button"
              title={mozL10n.get("settings_menu_button_tooltip")} />
-          <ul className={cx({"dropdown-menu": true, hide: !this.state.showMenu})}>
+          <ul className={cx({ "dropdown-menu": true, hide: !this.state.showMenu })}>
             <SettingsDropdownEntry
                 extraCSSClass="entry-settings-notifications entries-divider"
                 label={mozL10n.get(notificationsLabel)}
                 onClick={this.handleToggleNotifications} />
             <SettingsDropdownEntry
                 displayed={this._isSignedIn() && this.props.mozLoop.fxAEnabled}
                 extraCSSClass="entry-settings-account"
                 label={mozL10n.get("settings_menu_item_account")}
@@ -854,19 +854,19 @@ loop.panel = (function(_, mozL10n) {
     },
 
     _onStatusChanged: function() {
       var profile = this.props.mozLoop.userProfile;
       var currUid = this.state.userProfile ? this.state.userProfile.uid : null;
       var newUid = profile ? profile.uid : null;
       if (currUid === newUid) {
         // Update the state of hasEncryptionKey as this might have changed now.
-        this.setState({hasEncryptionKey: this.props.mozLoop.hasEncryptionKey});
+        this.setState({ hasEncryptionKey: this.props.mozLoop.hasEncryptionKey });
       } else {
-        this.setState({userProfile: profile});
+        this.setState({ userProfile: profile });
       }
       this.updateServiceErrors();
     },
 
     _gettingStartedSeen: function() {
       this.setState({
         gettingStartedSeen: this.props.mozLoop.getLoopPref("gettingStarted.seen")
       });
--- a/browser/components/loop/content/js/roomStore.js
+++ b/browser/components/loop/content/js/roomStore.js
@@ -130,17 +130,17 @@ loop.store = loop.store || {};
       this._mozLoop.rooms.on("delete", this._onRoomRemoved.bind(this));
       this._mozLoop.rooms.on("refresh", this._onRoomsRefresh.bind(this));
     },
 
     /**
      * Updates active room store state.
      */
     _onActiveRoomStoreChange: function() {
-      this.setStoreState({activeRoom: this.activeRoomStore.getStoreState()});
+      this.setStoreState({ activeRoom: this.activeRoomStore.getStoreState() });
     },
 
     /**
      * Updates current room list when a new room is available.
      *
      * @param {String} eventName     The event name (unused).
      * @param {Object} addedRoomData The added room data.
      */
@@ -272,17 +272,17 @@ loop.store = loop.store || {};
       }
 
       this._notifications.remove("create-room-error");
 
       this._mozLoop.rooms.create(roomCreationData, function(err, createdRoom) {
         var buckets = this._mozLoop.ROOM_CREATE;
         if (err) {
           this._mozLoop.telemetryAddValue("LOOP_ROOM_CREATE", buckets.CREATE_FAIL);
-          this.dispatchAction(new sharedActions.CreateRoomError({error: err}));
+          this.dispatchAction(new sharedActions.CreateRoomError({ error: err }));
           return;
         }
 
         this.dispatchAction(new sharedActions.CreatedRoom({
           roomToken: createdRoom.roomToken
         }));
         this._mozLoop.telemetryAddValue("LOOP_ROOM_CREATE", buckets.CREATE_SUCCESS);
 
@@ -296,17 +296,17 @@ loop.store = loop.store || {};
         }
       }.bind(this));
     },
 
     /**
      * Executed when a room has been created
      */
     createdRoom: function(actionData) {
-      this.setStoreState({pendingCreation: false});
+      this.setStoreState({ pendingCreation: false });
 
       // Opens the newly created room
       this.dispatchAction(new sharedActions.OpenRoom({
         roomToken: actionData.roomToken
       }));
     },
 
     /**
@@ -401,62 +401,62 @@ loop.store = loop.store || {};
      * Creates a new room.
      *
      * @param {sharedActions.DeleteRoom} actionData The action data.
      */
     deleteRoom: function(actionData) {
       this._mozLoop.rooms.delete(actionData.roomToken, function(err) {
         var buckets = this._mozLoop.ROOM_DELETE;
         if (err) {
-          this.dispatchAction(new sharedActions.DeleteRoomError({error: err}));
+          this.dispatchAction(new sharedActions.DeleteRoomError({ error: err }));
         }
         this._mozLoop.telemetryAddValue("LOOP_ROOM_DELETE", buckets[err ?
           "DELETE_FAIL" : "DELETE_SUCCESS"]);
       }.bind(this));
     },
 
     /**
      * Executed when a room deletion error occurs.
      *
      * @param {sharedActions.DeleteRoomError} actionData The action data.
      */
     deleteRoomError: function(actionData) {
-      this.setStoreState({error: actionData.error});
+      this.setStoreState({ error: actionData.error });
     },
 
     /**
      * Gather the list of all available rooms from the MozLoop API.
      */
     getAllRooms: function() {
       this._mozLoop.rooms.getAll(null, function(err, rawRoomList) {
         var action;
 
-        this.setStoreState({pendingInitialRetrieval: false});
+        this.setStoreState({ pendingInitialRetrieval: false });
 
         if (err) {
-          action = new sharedActions.GetAllRoomsError({error: err});
+          action = new sharedActions.GetAllRoomsError({ error: err });
         } else {
-          action = new sharedActions.UpdateRoomList({roomList: rawRoomList});
+          action = new sharedActions.UpdateRoomList({ roomList: rawRoomList });
         }
 
         this.dispatchAction(action);
 
         // We can only start listening to room events after getAll() has been
         // called executed first.
         this.startListeningToRoomEvents();
       }.bind(this));
     },
 
     /**
      * Updates current error state in case getAllRooms failed.
      *
      * @param {sharedActions.GetAllRoomsError} actionData The action data.
      */
     getAllRoomsError: function(actionData) {
-      this.setStoreState({error: actionData.error});
+      this.setStoreState({ error: actionData.error });
     },
 
     /**
      * Updates current room list.
      *
      * @param {sharedActions.UpdateRoomList} actionData The action data.
      */
     updateRoomList: function(actionData) {
@@ -536,17 +536,17 @@ loop.store = loop.store || {};
           setTimeout(function() {
             this.dispatchAction(new sharedActions.UpdateRoomContextDone());
           }.bind(this), 0);
           return;
         }
 
         var hadContextBefore = !!oldRoomURL;
 
-        this.setStoreState({error: null});
+        this.setStoreState({ error: null });
         this._mozLoop.rooms.update(actionData.roomToken, roomData,
           function(error, data) {
             var action = error ?
               new sharedActions.UpdateRoomContextError({ error: error }) :
               new sharedActions.UpdateRoomContextDone();
             this.dispatchAction(action);
 
             if (!err && !hadContextBefore) {
--- a/browser/components/loop/content/js/roomViews.js
+++ b/browser/components/loop/content/js/roomViews.js
@@ -47,26 +47,26 @@ loop.roomViews = (function(mozL10n) {
       }
     },
 
     _onRoomError: function() {
       // Only update the state if we're mounted, to avoid the problem where
       // stopListening doesn't nuke the active listeners during a event
       // processing.
       if (this.isMounted()) {
-        this.setState({error: this.props.roomStore.getStoreState("error")});
+        this.setState({ error: this.props.roomStore.getStoreState("error") });
       }
     },
 
     _onRoomSavingContext: function() {
       // Only update the state if we're mounted, to avoid the problem where
       // stopListening doesn't nuke the active listeners during a event
       // processing.
       if (this.isMounted()) {
-        this.setState({savingContext: this.props.roomStore.getStoreState("savingContext")});
+        this.setState({ savingContext: this.props.roomStore.getStoreState("savingContext") });
       }
     },
 
     getInitialState: function() {
       var storeState = this.props.roomStore.getStoreState("activeRoom");
       return _.extend({
         // Used by the UI showcase.
         roomState: this.props.roomState || storeState.roomState,
@@ -279,26 +279,26 @@ loop.roomViews = (function(mozL10n) {
     handleCopyButtonClick: function(event) {
       event.preventDefault();
 
       this.props.dispatcher.dispatch(new sharedActions.CopyRoomUrl({
         roomUrl: this.props.roomData.roomUrl,
         from: "conversation"
       }));
 
-      this.setState({copiedUrl: true});
+      this.setState({ copiedUrl: true });
       setTimeout(this.resetTriggeredButtons, this.constructor.TRIGGERED_RESET_DELAY);
     },
 
     /**
      * Reset state of triggered buttons if necessary
      */
     resetTriggeredButtons: function() {
       if (this.state.copiedUrl) {
-        this.setState({copiedUrl: false});
+        this.setState({ copiedUrl: false });
       }
     },
 
     handleShareButtonClick: function(event) {
       event.preventDefault();
 
       var providers = this.props.socialShareProviders;
       // If there are no providers available currently, save a click by dispatching
@@ -321,17 +321,17 @@ loop.roomViews = (function(mozL10n) {
       if (!this.props.show) {
         return null;
       }
 
       var cx = React.addons.classSet;
       return (
         React.createElement("div", {className: "room-invitation-overlay"}, 
           React.createElement("div", {className: "room-invitation-content"}, 
-            React.createElement("p", {className: cx({hide: this.props.showEditContext})}, 
+            React.createElement("p", {className: cx({ hide: this.props.showEditContext })}, 
               mozL10n.get("invite_header_text2")
             )
           ), 
           React.createElement("div", {className: cx({
             "btn-group": true,
             "call-action-group": true,
             hide: this.props.showEditContext
           })}, 
@@ -537,18 +537,18 @@ loop.roomViews = (function(mozL10n) {
       var thumbnail = url && url.thumbnail || "loop/shared/img/icons-16x16.svg#globe";
       var urlDescription = url && url.description || "";
       var location = url && url.location || "";
 
       var cx = React.addons.classSet;
       var availableContext = this.state.availableContext;
       return (
         React.createElement("div", {className: "room-context"}, 
-          React.createElement("p", {className: cx({"error": !!this.props.error,
-                            "error-display-area": true})}, 
+          React.createElement("p", {className: cx({ "error": !!this.props.error,
+                            "error-display-area": true })}, 
             mozL10n.get("rooms_change_failed_label")
           ), 
           React.createElement("h2", {className: "room-context-header"}, mozL10n.get("context_inroom_header")), 
           React.createElement("form", {onSubmit: this.handleFormSubmit}, 
             React.createElement("input", {className: "room-context-name", 
               maxLength: this.maxRoomNameLength, 
               onKeyDown: this.handleTextareaKeyDown, 
               placeholder: mozL10n.get("context_edit_name_placeholder"), 
@@ -810,26 +810,26 @@ loop.roomViews = (function(mozL10n) {
                 remotePosterUrl: this.props.remotePosterUrl, 
                 remoteSrcMediaElement: this.state.remoteSrcMediaElement, 
                 renderRemoteVideo: this.shouldRenderRemoteVideo(), 
                 screenShareMediaElement: this.state.screenShareMediaElement, 
                 screenSharePosterUrl: null, 
                 showContextRoomName: false, 
                 useDesktopPaths: true}, 
                 React.createElement(sharedViews.ConversationToolbar, {
-                  audio: {enabled: !this.state.audioMuted, visible: true}, 
+                  audio: { enabled: !this.state.audioMuted, visible: true}, 
                   dispatcher: this.props.dispatcher, 
                   hangup: this.leaveRoom, 
                   mozLoop: this.props.mozLoop, 
                   publishStream: this.publishStream, 
                   screenShare: screenShareData, 
                   settingsMenuItems: settingsMenuItems, 
                   show: !shouldRenderEditContextView, 
                   showHangup: this.props.chatWindowDetached, 
-                  video: {enabled: !this.state.videoMuted, visible: true}}), 
+                  video: { enabled: !this.state.videoMuted, visible: true}}), 
                 React.createElement(DesktopRoomInvitationView, {
                   dispatcher: this.props.dispatcher, 
                   error: this.state.error, 
                   mozLoop: this.props.mozLoop, 
                   onAddContextClick: this.handleAddContextClick, 
                   onEditContextClose: this.handleEditContextClose, 
                   roomData: roomData, 
                   savingContext: this.state.savingContext, 
--- a/browser/components/loop/content/js/roomViews.jsx
+++ b/browser/components/loop/content/js/roomViews.jsx
@@ -47,26 +47,26 @@ loop.roomViews = (function(mozL10n) {
       }
     },
 
     _onRoomError: function() {
       // Only update the state if we're mounted, to avoid the problem where
       // stopListening doesn't nuke the active listeners during a event
       // processing.
       if (this.isMounted()) {
-        this.setState({error: this.props.roomStore.getStoreState("error")});
+        this.setState({ error: this.props.roomStore.getStoreState("error") });
       }
     },
 
     _onRoomSavingContext: function() {
       // Only update the state if we're mounted, to avoid the problem where
       // stopListening doesn't nuke the active listeners during a event
       // processing.
       if (this.isMounted()) {
-        this.setState({savingContext: this.props.roomStore.getStoreState("savingContext")});
+        this.setState({ savingContext: this.props.roomStore.getStoreState("savingContext") });
       }
     },
 
     getInitialState: function() {
       var storeState = this.props.roomStore.getStoreState("activeRoom");
       return _.extend({
         // Used by the UI showcase.
         roomState: this.props.roomState || storeState.roomState,
@@ -279,26 +279,26 @@ loop.roomViews = (function(mozL10n) {
     handleCopyButtonClick: function(event) {
       event.preventDefault();
 
       this.props.dispatcher.dispatch(new sharedActions.CopyRoomUrl({
         roomUrl: this.props.roomData.roomUrl,
         from: "conversation"
       }));
 
-      this.setState({copiedUrl: true});
+      this.setState({ copiedUrl: true });
       setTimeout(this.resetTriggeredButtons, this.constructor.TRIGGERED_RESET_DELAY);
     },
 
     /**
      * Reset state of triggered buttons if necessary
      */
     resetTriggeredButtons: function() {
       if (this.state.copiedUrl) {
-        this.setState({copiedUrl: false});
+        this.setState({ copiedUrl: false });
       }
     },
 
     handleShareButtonClick: function(event) {
       event.preventDefault();
 
       var providers = this.props.socialShareProviders;
       // If there are no providers available currently, save a click by dispatching
@@ -321,17 +321,17 @@ loop.roomViews = (function(mozL10n) {
       if (!this.props.show) {
         return null;
       }
 
       var cx = React.addons.classSet;
       return (
         <div className="room-invitation-overlay">
           <div className="room-invitation-content">
-            <p className={cx({hide: this.props.showEditContext})}>
+            <p className={cx({ hide: this.props.showEditContext })}>
               {mozL10n.get("invite_header_text2")}
             </p>
           </div>
           <div className={cx({
             "btn-group": true,
             "call-action-group": true,
             hide: this.props.showEditContext
           })}>
@@ -537,18 +537,18 @@ loop.roomViews = (function(mozL10n) {
       var thumbnail = url && url.thumbnail || "loop/shared/img/icons-16x16.svg#globe";
       var urlDescription = url && url.description || "";
       var location = url && url.location || "";
 
       var cx = React.addons.classSet;
       var availableContext = this.state.availableContext;
       return (
         <div className="room-context">
-          <p className={cx({"error": !!this.props.error,
-                            "error-display-area": true})}>
+          <p className={cx({ "error": !!this.props.error,
+                            "error-display-area": true })}>
             {mozL10n.get("rooms_change_failed_label")}
           </p>
           <h2 className="room-context-header">{mozL10n.get("context_inroom_header")}</h2>
           <form onSubmit={this.handleFormSubmit}>
             <input className="room-context-name"
               maxLength={this.maxRoomNameLength}
               onKeyDown={this.handleTextareaKeyDown}
               placeholder={mozL10n.get("context_edit_name_placeholder")}
@@ -810,26 +810,26 @@ loop.roomViews = (function(mozL10n) {
                 remotePosterUrl={this.props.remotePosterUrl}
                 remoteSrcMediaElement={this.state.remoteSrcMediaElement}
                 renderRemoteVideo={this.shouldRenderRemoteVideo()}
                 screenShareMediaElement={this.state.screenShareMediaElement}
                 screenSharePosterUrl={null}
                 showContextRoomName={false}
                 useDesktopPaths={true}>
                 <sharedViews.ConversationToolbar
-                  audio={{enabled: !this.state.audioMuted, visible: true}}
+                  audio={{ enabled: !this.state.audioMuted, visible: true }}
                   dispatcher={this.props.dispatcher}
                   hangup={this.leaveRoom}
                   mozLoop={this.props.mozLoop}
                   publishStream={this.publishStream}
                   screenShare={screenShareData}
                   settingsMenuItems={settingsMenuItems}
                   show={!shouldRenderEditContextView}
                   showHangup={this.props.chatWindowDetached}
-                  video={{enabled: !this.state.videoMuted, visible: true}} />
+                  video={{ enabled: !this.state.videoMuted, visible: true }} />
                 <DesktopRoomInvitationView
                   dispatcher={this.props.dispatcher}
                   error={this.state.error}
                   mozLoop={this.props.mozLoop}
                   onAddContextClick={this.handleAddContextClick}
                   onEditContextClose={this.handleEditContextClose}
                   roomData={roomData}
                   savingContext={this.state.savingContext}
--- a/browser/components/loop/content/shared/js/activeRoomStore.js
+++ b/browser/components/loop/content/shared/js/activeRoomStore.js
@@ -591,17 +591,17 @@ loop.store.ActiveRoomStore = (function()
     _checkDevicesAndJoinRoom: function() {
       // XXX Ideally we'd do this check before joining a room, but we're waiting
       // for the UX for that. See bug 1166824. In the meantime this gives us
       // additional information for analysis.
       loop.shared.utils.hasAudioOrVideoDevices(function(hasDevices) {
         if (hasDevices) {
           // MEDIA_WAIT causes the views to dispatch sharedActions.SetupStreamElements,
           // which in turn starts the sdk obtaining the device permission.
-          this.setStoreState({roomState: ROOM_STATES.MEDIA_WAIT});
+          this.setStoreState({ roomState: ROOM_STATES.MEDIA_WAIT });
         } else {
           this.dispatchAction(new sharedActions.ConnectionFailure({
             reason: FAILURE_DETAILS.NO_MEDIA
           }));
         }
       }.bind(this));
     },
 
@@ -682,17 +682,17 @@ loop.store.ActiveRoomStore = (function()
       this._checkDevicesAndJoinRoom();
     },
 
     /**
      * Handles the action that signifies when media permission has been
      * granted and starts joining the room.
      */
     gotMediaPermission: function() {
-      this.setStoreState({roomState: ROOM_STATES.JOINING});
+      this.setStoreState({ roomState: ROOM_STATES.JOINING });
 
       this._mozLoop.rooms.join(this._storeState.roomToken,
         function(error, responseData) {
           if (error) {
             this.dispatchAction(new sharedActions.RoomFailure({
               error: error,
               // This is an explicit flag to avoid the leave happening if join
               // fails. We can't track it on ROOM_STATES.JOINING as the user
@@ -836,24 +836,24 @@ loop.store.ActiveRoomStore = (function()
         remoteVideoEnabled: actionData.videoEnabled
       });
     },
 
     /**
      * Records when the remote media has been connected.
      */
     mediaConnected: function() {
-      this.setStoreState({mediaConnected: true});
+      this.setStoreState({ mediaConnected: true });
     },
 
     /**
      * Used to note the current screensharing state.
      */
     screenSharingState: function(actionData) {
-      this.setStoreState({screenSharingState: actionData.state});
+      this.setStoreState({ screenSharingState: actionData.state });
 
       this._mozLoop.setScreenShareState(
         this.getStoreState().windowId,
         actionData.state === SCREEN_SHARE_STATES.ACTIVE);
     },
 
     /**
      * Used to note the current state of receiving screenshare data.
@@ -1114,17 +1114,17 @@ loop.store.ActiveRoomStore = (function()
           (this._storeState.roomState === ROOM_STATES.JOINING ||
            this._storeState.roomState === ROOM_STATES.JOINED ||
            this._storeState.roomState === ROOM_STATES.SESSION_CONNECTED ||
            this._storeState.roomState === ROOM_STATES.HAS_PARTICIPANTS)) {
         this._mozLoop.rooms.leave(this._storeState.roomToken,
           this._storeState.sessionToken);
       }
 
-      this.setStoreState({roomState: nextState});
+      this.setStoreState({ roomState: nextState });
     },
 
     /**
      * When feedback is complete, we go back to the ready state, rather than
      * init or gather, as we don't need to get the data from the server again.
      */
     feedbackComplete: function() {
       this.setStoreState({
--- a/browser/components/loop/content/shared/js/crypto.js
+++ b/browser/components/loop/content/shared/js/crypto.js
@@ -63,17 +63,17 @@ var inChrome = typeof Components != "und
    */
   function generateKey() {
     if (!isSupported()) {
       throw new Error("Web Crypto is not supported");
     }
 
     return new Promise(function(resolve, reject) {
       // First get a crypto key.
-      rootObject.crypto.subtle.generateKey({name: ALGORITHM, length: KEY_LENGTH },
+      rootObject.crypto.subtle.generateKey({ name: ALGORITHM, length: KEY_LENGTH },
         // `true` means that the key can be extracted from the CryptoKey object.
         true,
         // Usages for the key.
         ["encrypt", "decrypt"]
       ).then(function(cryptoKey) {
         // Now extract the key in the JSON web key format.
         return rootObject.crypto.subtle.exportKey(KEY_FORMAT, cryptoKey);
       }).then(function(exportedKey) {
@@ -100,17 +100,17 @@ var inChrome = typeof Components != "und
       throw new Error("Web Crypto is not supported");
     }
 
     var iv = new Uint8Array(INITIALIZATION_VECTOR_LENGTH);
 
     return new Promise(function(resolve, reject) {
       // First import the key to a format we can use.
       rootObject.crypto.subtle.importKey(KEY_FORMAT,
-        {k: key, kty: KEY_TYPE},
+        { k: key, kty: KEY_TYPE },
         ALGORITHM,
         // If the key is extractable.
         true,
         // What we're using it for.
         ["encrypt"]
       ).then(function(cryptoKey) {
         // Now we've got the cryptoKey, we can do the actual encryption.
 
@@ -153,17 +153,17 @@ var inChrome = typeof Components != "und
   function decryptBytes(key, encryptedData) {
     if (!isSupported()) {
       throw new Error("Web Crypto is not supported");
     }
 
     return new Promise(function(resolve, reject) {
       // First import the key to a format we can use.
       rootObject.crypto.subtle.importKey(KEY_FORMAT,
-        {k: key, kty: KEY_TYPE},
+        { k: key, kty: KEY_TYPE },
         ALGORITHM,
         // If the key is extractable.
         true,
         // What we're using it for.
         ["decrypt"]
       ).then(function(cryptoKey) {
         // Now we've got the key, start the decryption.
         var splitData = _splitIVandCipherText(encryptedData);
--- a/browser/components/loop/content/shared/js/mixins.js
+++ b/browser/components/loop/content/shared/js/mixins.js
@@ -246,21 +246,21 @@ loop.shared.mixins = (function() {
       },
 
       componentWillUnmount: function() {
         this.documentBody.removeEventListener("click", this._onBodyClick);
         rootObject.removeEventListener("blur", this.hideDropdownMenu);
       },
 
       showDropdownMenu: function() {
-        this.setState({showMenu: true}, this._correctMenuPosition);
+        this.setState({ showMenu: true }, this._correctMenuPosition);
       },
 
       hideDropdownMenu: function() {
-        this.setState({showMenu: false}, function() {
+        this.setState({ showMenu: false }, function() {
           var menu = this.refs.menu && this.refs.menu.getDOMNode();
           if (menu) {
             menu.style.visibility = "hidden";
           }
         });
       },
 
       toggleDropdownMenu: function() {
@@ -394,17 +394,17 @@ loop.shared.mixins = (function() {
         var error;
         if (request.status < 200 || request.status >= 300) {
           error = new Error(request.status + " " + request.statusText);
           callback(error);
           return;
         }
 
         var type = request.getResponseHeader("Content-Type");
-        var blob = new Blob([request.response], {type: type});
+        var blob = new Blob([request.response], { type: type });
         callback(null, blob);
       }.bind(this);
 
       this._audioRequest.send(null);
     },
 
     /**
      * Ensures audio is stopped playing, and removes the object from memory.
--- a/browser/components/loop/content/shared/js/models.js
+++ b/browser/components/loop/content/shared/js/models.js
@@ -27,17 +27,17 @@ loop.shared.models = (function(l10n) {
     model: NotificationModel,
 
     /**
      * Adds a warning notification to the stack and renders it.
      *
      * @return {String} message
      */
     warn: function(message) {
-      this.add({level: "warning", message: message});
+      this.add({ level: "warning", message: message });
     },
 
     /**
      * Adds a l10n warning notification to the stack and renders it.
      *
      * @param  {String} messageId L10n message id
      */
     warnL10n: function(messageId) {
@@ -45,17 +45,17 @@ loop.shared.models = (function(l10n) {
     },
 
     /**
      * Adds an error notification to the stack and renders it.
      *
      * @return {String} message
      */
     error: function(message) {
-      this.add({level: "error", message: message});
+      this.add({ level: "error", message: message });
     },
 
     /**
      * Adds a l10n error notification to the stack and renders it.
      *
      * @param  {String} messageId L10n message id
      * @param  {Object} [l10nProps] An object with variables to be interpolated
      *                  into the translation. All members' values must be
@@ -66,17 +66,17 @@ loop.shared.models = (function(l10n) {
     },
 
     /**
      * Adds a success notification to the stack and renders it.
      *
      * @return {String} message
      */
     success: function(message) {
-      this.add({level: "success", message: message});
+      this.add({ level: "success", message: message });
     },
 
     /**
      * Adds a l10n success notification to the stack and renders it.
      *
      * @param  {String} messageId L10n message id
      * @param  {Object} [l10nProps] An object with variables to be interpolated
      *                  into the translation. All members' values must be
--- a/browser/components/loop/content/shared/js/otSdkDriver.js
+++ b/browser/components/loop/content/shared/js/otSdkDriver.js
@@ -64,20 +64,20 @@ loop.OTSdkDriver = (function() {
       // If there's no getSources function, the sdk defines its own and caches
       // the result. So here we define our own one which wraps around the
       // real device enumeration api.
       window.MediaStreamTrack.getSources = function(callback) {
         navigator.mediaDevices.enumerateDevices().then(function(devices) {
           var result = [];
           devices.forEach(function(device) {
             if (device.kind === "audioinput") {
-              result.push({kind: "audio"});
+              result.push({ kind: "audio" });
             }
             if (device.kind === "videoinput") {
-              result.push({kind: "video"});
+              result.push({ kind: "video" });
             }
           });
           callback(result);
         });
       };
     }
   };
 
--- a/browser/components/loop/content/shared/js/textChatView.js
+++ b/browser/components/loop/content/shared/js/textChatView.js
@@ -36,18 +36,18 @@ loop.shared.views.chat = (function(mozL1
     _renderTimestamp: function() {
       var date = new Date(this.props.timestamp);
       var language = mozL10n.language ? mozL10n.language.code
                                       : mozL10n.getLanguage();
 
       return (
         React.createElement("span", {className: "text-chat-entry-timestamp"}, 
           date.toLocaleTimeString(language,
-                                   {hour: "numeric", minute: "numeric",
-                                   hour12: false})
+                                   { hour: "numeric", minute: "numeric",
+                                   hour12: false })
         )
       );
     },
 
     render: function() {
       var classes = React.addons.classSet({
         "text-chat-entry": true,
         "received": this.props.type === CHAT_MESSAGE_TYPES.RECEIVED,
@@ -77,17 +77,17 @@ loop.shared.views.chat = (function(mozL1
 
     propTypes: {
       message: React.PropTypes.string.isRequired
     },
 
     render: function() {
       return (
         React.createElement("div", {className: "text-chat-header special room-name"}, 
-          React.createElement("p", null, mozL10n.get("rooms_welcome_title", {conversationName: this.props.message}))
+          React.createElement("p", null, mozL10n.get("rooms_welcome_title", { conversationName: this.props.message }))
         )
       );
     }
   });
 
   /**
    * Manages the text entries in the chat entries view. This is split out from
    * TextChatView so that scrolling can be managed more efficiently - this
@@ -135,17 +135,17 @@ loop.shared.views.chat = (function(mozL1
     componentWillReceiveProps: function(nextProps) {
       var receivedMessageCount = nextProps.messageList.filter(function(message) {
         return message.type === CHAT_MESSAGE_TYPES.RECEIVED;
       }).length;
 
       // If the number of received messages has increased, we play a sound.
       if (receivedMessageCount > this.state.receivedMessageCount) {
         this.play("message");
-        this.setState({receivedMessageCount: receivedMessageCount});
+        this.setState({ receivedMessageCount: receivedMessageCount });
       }
     },
 
     componentDidUpdate: function() {
       // Don't scroll if we haven't got any chat messages yet - e.g. for context
       // display, we want to display starting at the top.
       if (this.shouldScroll && this._hasChatMessages()) {
         // This ensures the paint is complete.
--- a/browser/components/loop/content/shared/js/textChatView.jsx
+++ b/browser/components/loop/content/shared/js/textChatView.jsx
@@ -36,18 +36,18 @@ loop.shared.views.chat = (function(mozL1
     _renderTimestamp: function() {
       var date = new Date(this.props.timestamp);
       var language = mozL10n.language ? mozL10n.language.code
                                       : mozL10n.getLanguage();
 
       return (
         <span className="text-chat-entry-timestamp">
           {date.toLocaleTimeString(language,
-                                   {hour: "numeric", minute: "numeric",
-                                   hour12: false})}
+                                   { hour: "numeric", minute: "numeric",
+                                   hour12: false })}
         </span>
       );
     },
 
     render: function() {
       var classes = React.addons.classSet({
         "text-chat-entry": true,
         "received": this.props.type === CHAT_MESSAGE_TYPES.RECEIVED,
@@ -77,17 +77,17 @@ loop.shared.views.chat = (function(mozL1
 
     propTypes: {
       message: React.PropTypes.string.isRequired
     },
 
     render: function() {
       return (
         <div className="text-chat-header special room-name">
-          <p>{mozL10n.get("rooms_welcome_title", {conversationName: this.props.message})}</p>
+          <p>{mozL10n.get("rooms_welcome_title", { conversationName: this.props.message })}</p>
         </div>
       );
     }
   });
 
   /**
    * Manages the text entries in the chat entries view. This is split out from
    * TextChatView so that scrolling can be managed more efficiently - this
@@ -135,17 +135,17 @@ loop.shared.views.chat = (function(mozL1
     componentWillReceiveProps: function(nextProps) {
       var receivedMessageCount = nextProps.messageList.filter(function(message) {
         return message.type === CHAT_MESSAGE_TYPES.RECEIVED;
       }).length;
 
       // If the number of received messages has increased, we play a sound.
       if (receivedMessageCount > this.state.receivedMessageCount) {
         this.play("message");
-        this.setState({receivedMessageCount: receivedMessageCount});
+        this.setState({ receivedMessageCount: receivedMessageCount });
       }
     },
 
     componentDidUpdate: function() {
       // Don't scroll if we haven't got any chat messages yet - e.g. for context
       // display, we want to display starting at the top.
       if (this.shouldScroll && this._hasChatMessages()) {
         // This ensures the paint is complete.
--- a/browser/components/loop/content/shared/js/utils.js
+++ b/browser/components/loop/content/shared/js/utils.js
@@ -37,17 +37,17 @@ var inChrome = typeof Components != "und
     rootNavigator = navigatorObj || navigator;
   }
 
   var mozL10n;
   if (inChrome) {
     this.EXPORTED_SYMBOLS = ["utils"];
     mozL10n = { get: function() {
       throw new Error("mozL10n.get not availabled from chrome!");
-    }};
+    } };
   } else {
     mozL10n = document.mozL10n || navigator.mozL10n;
   }
 
   /**
    * Call types used for determining if a call is audio/video or audio-only.
    */
   var CALL_TYPES = {
@@ -111,17 +111,17 @@ var inChrome = typeof Components != "und
   /**
    * Format a given date into an l10n-friendly string.
    *
    * @param {Integer} The timestamp in seconds to format.
    * @return {String} The formatted string.
    */
   function formatDate(timestamp) {
     var date = (new Date(timestamp * 1000));
-    var options = {year: "numeric", month: "long", day: "numeric"};
+    var options = { year: "numeric", month: "long", day: "numeric" };
     return date.toLocaleDateString(navigator.language, options);
   }
 
   /**
    * Used for getting a boolean preference. It will either use the browser preferences
    * (if navigator.mozLoop is defined) or try to get them from localStorage.
    *
    * @param {String} prefName The name of the preference. Note that mozLoop adds
--- a/browser/components/loop/content/shared/js/views.js
+++ b/browser/components/loop/content/shared/js/views.js
@@ -57,17 +57,17 @@ loop.shared.views = (function(_, mozL10n
       enabled: React.PropTypes.bool.isRequired,
       scope: React.PropTypes.string.isRequired,
       title: React.PropTypes.string,
       type: React.PropTypes.string.isRequired,
       visible: React.PropTypes.bool.isRequired
     },
 
     getDefaultProps: function() {
-      return {enabled: true, visible: true};
+      return { enabled: true, visible: true };
     },
 
     handleClick: function() {
       this.props.action();
     },
 
     _getClasses: function() {
       var cx = React.addons.classSet;
@@ -384,19 +384,19 @@ loop.shared.views = (function(_, mozL10n
   });
 
   /**
    * Conversation controls.
    */
   var ConversationToolbar = React.createClass({displayName: "ConversationToolbar",
     getDefaultProps: function() {
       return {
-        video: {enabled: true, visible: true},
-        audio: {enabled: true, visible: true},
-        screenShare: {state: SCREEN_SHARE_STATES.INACTIVE, visible: false},
+        video: { enabled: true, visible: true },
+        audio: { enabled: true, visible: true },
+        screenShare: { state: SCREEN_SHARE_STATES.INACTIVE, visible: false },
         settingsMenuItems: null,
         showHangup: true
       };
     },
 
     getInitialState: function() {
       return {
         idle: false
@@ -441,17 +441,17 @@ loop.shared.views = (function(_, mozL10n
     },
 
     /**
      * If the conversation toolbar is idle, update its state and initialize the countdown
      * to return of the idle state. If the toolbar is active, only it's updated the userActivity flag.
      */
     _onBodyMouseMove: function() {
       if (this.state.idle) {
-        this.setState({idle: false});
+        this.setState({ idle: false });
         this.startIdleCountDown();
       } else {
         this.userActivity = true;
       }
     },
 
     /**
      * Instead of resetting the timeout for every mousemove (this event is called to many times,
@@ -479,17 +479,17 @@ loop.shared.views = (function(_, mozL10n
      * Launchs the process to check the user activity and the inactivity countdown to change
      * the toolbar to idle.
      * When the toolbar changes to idle, we remove the procces to check the user activity,
      * because the toolbar is going to be updated directly when the user moves the mouse.
      */
     startIdleCountDown: function() {
       this.checkUserActivity();
       this.inactivityTimeout = setTimeout(function() {
-        this.setState({idle: true});
+        this.setState({ idle: true });
         clearInterval(this.inactivityPollInterval);
       }.bind(this), 6000);
     },
 
     render: function() {
       if (!this.props.show) {
         return null;
       }
@@ -578,17 +578,17 @@ loop.shared.views = (function(_, mozL10n
     mixins: [Backbone.Events, sharedMixins.DocumentVisibilityMixin],
 
     propTypes: {
       clearOnDocumentHidden: React.PropTypes.bool,
       notifications: React.PropTypes.object.isRequired
     },
 
     getDefaultProps: function() {
-      return {clearOnDocumentHidden: false};
+      return { clearOnDocumentHidden: false };
     },
 
     componentDidMount: function() {
       this.listenTo(this.props.notifications, "reset add remove", function() {
         this.forceUpdate();
       });
     },
 
@@ -602,17 +602,17 @@ loop.shared.views = (function(_, mozL10n
      * true and the collection isn't empty.
      */
     onDocumentHidden: function() {
       if (this.props.clearOnDocumentHidden &&
           this.props.notifications.length > 0) {
         // Note: The `silent` option prevents the `reset` event to be triggered
         // here, preventing the UI to "jump" a little because of the event
         // callback being processed in another tick (I think).
-        this.props.notifications.reset([], {silent: true});
+        this.props.notifications.reset([], { silent: true });
         this.forceUpdate();
       }
     },
 
     render: function() {
       return (
         React.createElement("div", {className: "messages"}, 
           this.props.notifications.map(function(notification, key) {
--- a/browser/components/loop/content/shared/js/views.jsx
+++ b/browser/components/loop/content/shared/js/views.jsx
@@ -57,17 +57,17 @@ loop.shared.views = (function(_, mozL10n
       enabled: React.PropTypes.bool.isRequired,
       scope: React.PropTypes.string.isRequired,
       title: React.PropTypes.string,
       type: React.PropTypes.string.isRequired,
       visible: React.PropTypes.bool.isRequired
     },
 
     getDefaultProps: function() {
-      return {enabled: true, visible: true};
+      return { enabled: true, visible: true };
     },
 
     handleClick: function() {
       this.props.action();
     },
 
     _getClasses: function() {
       var cx = React.addons.classSet;
@@ -384,19 +384,19 @@ loop.shared.views = (function(_, mozL10n
   });
 
   /**
    * Conversation controls.
    */
   var ConversationToolbar = React.createClass({
     getDefaultProps: function() {
       return {
-        video: {enabled: true, visible: true},
-        audio: {enabled: true, visible: true},
-        screenShare: {state: SCREEN_SHARE_STATES.INACTIVE, visible: false},
+        video: { enabled: true, visible: true },
+        audio: { enabled: true, visible: true },
+        screenShare: { state: SCREEN_SHARE_STATES.INACTIVE, visible: false },
         settingsMenuItems: null,
         showHangup: true
       };
     },
 
     getInitialState: function() {
       return {
         idle: false
@@ -441,17 +441,17 @@ loop.shared.views = (function(_, mozL10n
     },
 
     /**
      * If the conversation toolbar is idle, update its state and initialize the countdown
      * to return of the idle state. If the toolbar is active, only it's updated the userActivity flag.
      */
     _onBodyMouseMove: function() {
       if (this.state.idle) {
-        this.setState({idle: false});
+        this.setState({ idle: false });
         this.startIdleCountDown();
       } else {
         this.userActivity = true;
       }
     },
 
     /**
      * Instead of resetting the timeout for every mousemove (this event is called to many times,
@@ -479,17 +479,17 @@ loop.shared.views = (function(_, mozL10n
      * Launchs the process to check the user activity and the inactivity countdown to change
      * the toolbar to idle.
      * When the toolbar changes to idle, we remove the procces to check the user activity,
      * because the toolbar is going to be updated directly when the user moves the mouse.
      */
     startIdleCountDown: function() {
       this.checkUserActivity();
       this.inactivityTimeout = setTimeout(function() {
-        this.setState({idle: true});
+        this.setState({ idle: true });
         clearInterval(this.inactivityPollInterval);
       }.bind(this), 6000);
     },
 
     render: function() {
       if (!this.props.show) {
         return null;
       }
@@ -578,17 +578,17 @@ loop.shared.views = (function(_, mozL10n
     mixins: [Backbone.Events, sharedMixins.DocumentVisibilityMixin],
 
     propTypes: {
       clearOnDocumentHidden: React.PropTypes.bool,
       notifications: React.PropTypes.object.isRequired
     },
 
     getDefaultProps: function() {
-      return {clearOnDocumentHidden: false};
+      return { clearOnDocumentHidden: false };
     },
 
     componentDidMount: function() {
       this.listenTo(this.props.notifications, "reset add remove", function() {
         this.forceUpdate();
       });
     },
 
@@ -602,17 +602,17 @@ loop.shared.views = (function(_, mozL10n
      * true and the collection isn't empty.
      */
     onDocumentHidden: function() {
       if (this.props.clearOnDocumentHidden &&
           this.props.notifications.length > 0) {
         // Note: The `silent` option prevents the `reset` event to be triggered
         // here, preventing the UI to "jump" a little because of the event
         // callback being processed in another tick (I think).
-        this.props.notifications.reset([], {silent: true});
+        this.props.notifications.reset([], { silent: true });
         this.forceUpdate();
       }
     },
 
     render: function() {
       return (
         <div className="messages">
           {this.props.notifications.map(function(notification, key) {
--- a/browser/components/loop/modules/GoogleImporter.jsm
+++ b/browser/components/loop/modules/GoogleImporter.jsm
@@ -165,17 +165,17 @@ this.GoogleImporter.prototype = {
    *                                 open a window for the OAuth process with chrome
    *                                 privileges.
    */
   startImport: function(options, callback, db, windowRef) {
     Task.spawn(function* () {
       let code = yield this._promiseAuthCode(windowRef);
       let tokenSet = yield this._promiseTokenSet(code);
       let contactEntries = yield this._getContactEntries(tokenSet);
-      let {total, success, ids} = yield this._processContacts(contactEntries, db, tokenSet);
+      let { total, success, ids } = yield this._processContacts(contactEntries, db, tokenSet);
       yield this._purgeContacts(ids, db);
 
       return {
         total: total,
         success: success
       };
     }.bind(this)).then(stats => callback(null, stats),
                        error => callback(error))
--- a/browser/components/loop/modules/LoopContacts.jsm
+++ b/browser/components/loop/modules/LoopContacts.jsm
@@ -1,28 +1,28 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 
-const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
+const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
 
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "console",
                                   "resource://gre/modules/Console.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "LoopStorage",
                                   "resource:///modules/loop/LoopStorage.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Promise",
                                   "resource://gre/modules/Promise.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "CardDavImporter",
                                   "resource:///modules/loop/CardDavImporter.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "GoogleImporter",
                                   "resource:///modules/loop/GoogleImporter.jsm");
 XPCOMUtils.defineLazyGetter(this, "eventEmitter", function() {
-  const {EventEmitter} = Cu.import("resource://devtools/shared/event-emitter.js", {});
+  const { EventEmitter } = Cu.import("resource://devtools/shared/event-emitter.js", {});
   return new EventEmitter();
 });
 
 this.EXPORTED_SYMBOLS = ["LoopContacts"];
 
 const kObjectStoreName = "contacts";
 
 /*
@@ -308,17 +308,17 @@ LoopStorage.on("upgrade", function(e, db
     return;
   }
 
   // Create the 'contacts' store as it doesn't exist yet.
   let store = db.createObjectStore(kObjectStoreName, {
     keyPath: kKeyPath,
     autoIncrement: true
   });
-  store.createIndex(kServiceIdIndex, kServiceIdIndex, {unique: false});
+  store.createIndex(kServiceIdIndex, kServiceIdIndex, { unique: false });
 });
 
 /**
  * The Contacts class.
  *
  * Each method that is a member of this class requires the last argument to be a
  * callback Function. MozLoopAPI will cause things to break if this invariant is
  * violated. You'll notice this as well in the documentation for each method.
--- a/browser/components/loop/modules/LoopRooms.jsm
+++ b/browser/components/loop/modules/LoopRooms.jsm
@@ -1,30 +1,30 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 
-const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
+const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
 
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/Task.jsm");
 Cu.import("resource://gre/modules/Timer.jsm");
 
-const {MozLoopService, LOOP_SESSION_TYPE} = Cu.import("resource:///modules/loop/MozLoopService.jsm", {});
+const { MozLoopService, LOOP_SESSION_TYPE } = Cu.import("resource:///modules/loop/MozLoopService.jsm", {});
 XPCOMUtils.defineLazyModuleGetter(this, "Promise",
                                   "resource://gre/modules/Promise.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "CommonUtils",
                                   "resource://services-common/utils.js");
 XPCOMUtils.defineLazyModuleGetter(this, "WebChannel",
                                   "resource://gre/modules/WebChannel.jsm");
 
 XPCOMUtils.defineLazyGetter(this, "eventEmitter", function() {
-  const {EventEmitter} = Cu.import("resource://devtools/shared/event-emitter.js", {});
+  const { EventEmitter } = Cu.import("resource://devtools/shared/event-emitter.js", {});
   return new EventEmitter();
 });
 XPCOMUtils.defineLazyGetter(this, "gLoopBundle", function() {
   return Services.strings.createBundle("chrome://browser/locale/loop/loop.properties");
 });
 
 XPCOMUtils.defineLazyModuleGetter(this, "LoopRoomsCache",
   "resource:///modules/loop/LoopRoomsCache.jsm");
@@ -651,17 +651,17 @@ var LoopRoomsInternal = {
       return;
     }
 
     if (!("roomOwner" in room)) {
       room.roomOwner = "-";
     }
 
     Task.spawn(function* () {
-      let {all, encrypted} = yield this.promiseEncryptRoomData(room);
+      let { all, encrypted } = yield this.promiseEncryptRoomData(room);
 
       // Save both sets of data...
       room = all;
       // ...but only send the encrypted data.
       let response = yield MozLoopService.hawkRequest(this.sessionType, "/rooms",
         "POST", encrypted);
 
       extend(room, JSON.parse(response.body));
@@ -880,17 +880,17 @@ var LoopRoomsInternal = {
                                        room.roomName;
     }
     if (roomData.urls && roomData.urls.length) {
       // For now we only support adding one URL to the room context.
       room.decryptedContext.urls = [roomData.urls[0]];
     }
 
     Task.spawn(function* () {
-      let {all, encrypted} = yield this.promiseEncryptRoomData(room);
+      let { all, encrypted } = yield this.promiseEncryptRoomData(room);
 
       // For patch, we only send the context data.
       let sendData = {
         context: encrypted.context
       };
 
       // This might be an upgrade to encrypted rename, so store the key
       // just in case.
--- a/browser/components/loop/modules/LoopRoomsCache.jsm
+++ b/browser/components/loop/modules/LoopRoomsCache.jsm
@@ -1,19 +1,19 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 
-const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
+const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
 
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/Task.jsm");
-const {MozLoopService, LOOP_SESSION_TYPE} =
+const { MozLoopService, LOOP_SESSION_TYPE } =
   Cu.import("resource:///modules/loop/MozLoopService.jsm", {});
 XPCOMUtils.defineLazyModuleGetter(this, "CommonUtils",
                                   "resource://services-common/utils.js");
 XPCOMUtils.defineLazyModuleGetter(this, "OS", "resource://gre/modules/osfile.jsm");
 
 this.EXPORTED_SYMBOLS = ["LoopRoomsCache"];
 
 const LOOP_ROOMS_CACHE_FILENAME = "loopRoomsCache.json";
@@ -58,17 +58,17 @@ LoopRoomsCache.prototype = {
    * Updates the local copy of the cache and saves it to disk.
    *
    * @param  {Object} contents An object to be saved in json format.
    * @return {Promise} A promise that is resolved once the save is complete.
    */
   _setCache: function(contents) {
     this._cache = contents;
 
-    return OS.File.makeDir(this.baseDir, {ignoreExisting: true}).then(() => {
+    return OS.File.makeDir(this.baseDir, { ignoreExisting: true }).then(() => {
         return CommonUtils.writeJSON(contents, this.path);
       });
   },
 
   /**
    * Returns the local copy of the cache if there is one, otherwise it reads
    * it from the disk.
    *
--- a/browser/components/loop/modules/LoopStorage.jsm
+++ b/browser/components/loop/modules/LoopStorage.jsm
@@ -1,30 +1,30 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 
-const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
+const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
 
 // Make it possible to load LoopStorage.jsm in xpcshell tests
 try {
   Cu.importGlobalProperties(["indexedDB"]);
 } catch (ex) {
   // don't write this is out in xpcshell, since it's expected there
   if (typeof window !== "undefined" && "console" in window) {
     console.log("Failed to import indexedDB; if this isn't a unit test," +
                 " something is wrong", ex);
   }
 }
 
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 XPCOMUtils.defineLazyGetter(this, "eventEmitter", function() {
-  const {EventEmitter} = Cu.import("resource://devtools/shared/event-emitter.js", {});
+  const { EventEmitter } = Cu.import("resource://devtools/shared/event-emitter.js", {});
   return new EventEmitter();
 });
 
 this.EXPORTED_SYMBOLS = ["LoopStorage"];
 
 const kDatabasePrefix = "loop-";
 const kDefaultDatabaseName = "default";
 var gDatabaseName = kDatabasePrefix + kDefaultDatabaseName;
--- a/browser/components/loop/modules/MozLoopPushHandler.jsm
+++ b/browser/components/loop/modules/MozLoopPushHandler.jsm
@@ -421,18 +421,18 @@ var MozLoopPushHandler = {
 
     this._initDone = false;
     this._retryManager.reset();
     this._pingMonitor.stop();
 
     // Un-register each active notification channel
     if (this.connectionState === CONNECTION_STATE_OPEN) {
       Object.keys(this.registeredChannels).forEach((id) => {
-        let unRegMsg = {messageType: "unregister",
-                        channelID: id};
+        let unRegMsg = { messageType: "unregister",
+                        channelID: id };
         this._pushSocket.send(unRegMsg);
       });
       this.registeredChannels = {};
     }
 
     this.connectionState = CONNECTION_STATE_CLOSED;
     this.serviceState = SERVICE_STATE_OFFLINE;
     this._pushSocket.close();
@@ -485,23 +485,23 @@ var MozLoopPushHandler = {
     consoleLog.info("PushHandler: channel registration: ", channelID);
     if (this.channels.has(channelID)) {
       // If this channel has an active registration with the PushServer
       // call the onRegister callback with the URL.
       if (this.registeredChannels[channelID]) {
         onRegistered(null, this.registeredChannels[channelID], channelID);
       }
       // Update the channel record.
-      this.channels.set(channelID, {onRegistered: onRegistered,
-                        onNotification: onNotification});
+      this.channels.set(channelID, { onRegistered: onRegistered,
+                        onNotification: onNotification });
       return;
     }
 
-    this.channels.set(channelID, {onRegistered: onRegistered,
-                                  onNotification: onNotification});
+    this.channels.set(channelID, { onRegistered: onRegistered,
+                                  onNotification: onNotification });
     this._channelsToRegister.push(channelID);
     this._registerChannels();
   },
 
   /**
    * Un-register a notification channel.
    *
    * @param {String} channelID Notification channel ID.
@@ -512,18 +512,18 @@ var MozLoopPushHandler = {
       return;
     }
 
     this.channels.delete(channelID);
 
     if (this.registeredChannels[channelID]) {
       delete this.registeredChannels[channelID];
       if (this.connectionState === CONNECTION_STATE_OPEN) {
-        this._pushSocket.send({messageType: "unregister",
-                               channelID: channelID});
+        this._pushSocket.send({ messageType: "unregister",
+                               channelID: channelID });
       }
     }
   },
 
   /**
    * Handles the start of the websocket stream.
    * Sends a hello message to the server.
    *
@@ -685,18 +685,18 @@ var MozLoopPushHandler = {
           ackChannels.push(update);
         } else {
           consoleLog.error("PushHandler: notification received for unknown channelID: ",
                            update.channelID);
         }
       });
 
       consoleLog.log("PushHandler: PusherServer 'ack': ", ackChannels);
-      this._pushSocket.send({messageType: "ack",
-                             updates: ackChannels});
+      this._pushSocket.send({ messageType: "ack",
+                             updates: ackChannels });
      }
    },
 
   /**
    * Handles the PushServer registration response.
    *
    * @param {Object} msg PushServer to UserAgent registration response (parsed from JSON).
    */
@@ -861,13 +861,13 @@ var MozLoopPushHandler = {
 
   /**
    * Handles registering a service
    *
    * @param {string} channelID - identification token to use in registration for this channel.
    */
   _sendRegistration: function(channelID) {
     if (channelID) {
-      this._pushSocket.send({messageType: "register",
-                             channelID: channelID});
+      this._pushSocket.send({ messageType: "register",
+                             channelID: channelID });
     }
   }
 };
--- a/browser/components/loop/modules/MozLoopService.jsm
+++ b/browser/components/loop/modules/MozLoopService.jsm
@@ -501,17 +501,17 @@ var MozLoopServiceInternal = {
       pushURLs = { rooms: undefined };
       this.pushURLs.set(sessionType, pushURLs);
     }
 
     if (pushURLs[serviceType] == pushURL) {
       return Promise.resolve(pushURL);
     }
 
-    let newURLs = {rooms: pushURLs.rooms};
+    let newURLs = { rooms: pushURLs.rooms };
     newURLs[serviceType] = pushURL;
 
     return this.hawkRequestInternal(sessionType, "/registration", "POST",
                                     { simplePushURLs: newURLs }).then(
       (response) => {
         // If this failed we got an invalid token.
         if (!this.storeSessionToken(sessionType, response.headers)) {
           throw new Error("session-token-wrong-size");
@@ -1748,17 +1748,17 @@ this.MozLoopService = {
     }
     if (aSrc) {
       url.searchParams.set("utm_source", "firefox-browser");
       url.searchParams.set("utm_medium", "firefox-browser");
       url.searchParams.set("utm_campaign", aSrc);
     }
 
     // Find the most recent pageID that has the Loop prefix.
-    let mostRecentLoopPageID = {id: null, lastSeen: null};
+    let mostRecentLoopPageID = { id: null, lastSeen: null };
     for (let pageID of UITour.pageIDsForSession) {
       if (pageID[0] && pageID[0].startsWith("hello-tour_OpenPanel_") &&
           pageID[1] && pageID[1].lastSeen > mostRecentLoopPageID.lastSeen) {
         mostRecentLoopPageID.id = pageID[0];
         mostRecentLoopPageID.lastSeen = pageID[1].lastSeen;
       }
     }
 
--- a/browser/components/loop/standalone/content/js/standaloneRoomViews.js
+++ b/browser/components/loop/standalone/content/js/standaloneRoomViews.js
@@ -47,17 +47,17 @@ loop.standaloneRoomViews = (function(moz
         }));
       }
     },
 
     render: function() {
       return (
         React.createElement("p", {
           className: "terms-service", 
-          dangerouslySetInnerHTML: {__html: this._getContent()}, 
+          dangerouslySetInnerHTML: { __html: this._getContent()}, 
           onClick: this.recordClick})
       );
     }
   });
 
   var StandaloneHandleUserAgentView = React.createClass({displayName: "StandaloneHandleUserAgentView",
     mixins: [
       loop.store.StoreMixin("activeRoomStore")
@@ -312,17 +312,17 @@ loop.standaloneRoomViews = (function(moz
                 mozL10n.get("rooms_room_join_label")
               ), 
               React.createElement(ToSView, {dispatcher: this.props.dispatcher})
             )
           );
         }
         case ROOM_STATES.MEDIA_WAIT: {
           var msg = mozL10n.get("call_progress_getting_media_description",
-                                {clientShortname: mozL10n.get("clientShortname2")});
+                                { clientShortname: mozL10n.get("clientShortname2") });
           var utils = loop.shared.utils;
           var isChrome = utils.isChrome(navigator.userAgent);
           var isFirefox = utils.isFirefox(navigator.userAgent);
           var isOpera = utils.isOpera(navigator.userAgent);
           var promptMediaMessageClasses = React.addons.classSet({
             "prompt-media-message": true,
             "chrome": isChrome,
             "firefox": isFirefox,
@@ -454,17 +454,17 @@ loop.standaloneRoomViews = (function(moz
         } else {
           this.setTitle(mozL10n.get("clientShortname2"));
         }
       }
 
       if (this.state.roomState !== ROOM_STATES.MEDIA_WAIT &&
           nextState.roomState === ROOM_STATES.MEDIA_WAIT) {
         this.props.dispatcher.dispatch(new sharedActions.SetupStreamElements({
-          publisherConfig: this.getDefaultPublisherConfig({publishVideo: true})
+          publisherConfig: this.getDefaultPublisherConfig({ publishVideo: true })
         }));
       }
 
       // UX don't want to surface these errors (as they would imply the user
       // needs to do something to fix them, when if they're having a conversation
       // they just need to connect). However, we do want there to be somewhere to
       // find reasonably easily, in case there's issues raised.
       if (!this.state.roomInfoFailure && nextState.roomInfoFailure) {
@@ -623,23 +623,23 @@ loop.standaloneRoomViews = (function(moz
             React.createElement(StandaloneRoomInfoArea, {activeRoomStore: this.props.activeRoomStore, 
               dispatcher: this.props.dispatcher, 
               failureReason: this.state.failureReason, 
               isFirefox: this.props.isFirefox, 
               joinRoom: this.joinRoom, 
               roomState: this.state.roomState, 
               roomUsed: this.state.used}), 
             React.createElement(sharedViews.ConversationToolbar, {
-              audio: {enabled: !this.state.audioMuted,
+              audio: { enabled: !this.state.audioMuted,
                       visible: this._roomIsActive()}, 
               dispatcher: this.props.dispatcher, 
               hangup: this.leaveRoom, 
               publishStream: this.publishStream, 
               show: true, 
-              video: {enabled: !this.state.videoMuted,
+              video: { enabled: !this.state.videoMuted,
                       visible: this._roomIsActive()}})
           )
         )
       );
     }
   });
 
   var StandaloneOverlayWrapper = React.createClass({displayName: "StandaloneOverlayWrapper",
--- a/browser/components/loop/standalone/content/js/standaloneRoomViews.jsx
+++ b/browser/components/loop/standalone/content/js/standaloneRoomViews.jsx
@@ -47,17 +47,17 @@ loop.standaloneRoomViews = (function(moz
         }));
       }
     },
 
     render: function() {
       return (
         <p
           className="terms-service"
-          dangerouslySetInnerHTML={{__html: this._getContent()}}
+          dangerouslySetInnerHTML={{ __html: this._getContent() }}
           onClick={this.recordClick}></p>
       );
     }
   });
 
   var StandaloneHandleUserAgentView = React.createClass({
     mixins: [
       loop.store.StoreMixin("activeRoomStore")
@@ -312,17 +312,17 @@ loop.standaloneRoomViews = (function(moz
                 {mozL10n.get("rooms_room_join_label")}
               </button>
               <ToSView dispatcher={this.props.dispatcher} />
             </div>
           );
         }
         case ROOM_STATES.MEDIA_WAIT: {
           var msg = mozL10n.get("call_progress_getting_media_description",
-                                {clientShortname: mozL10n.get("clientShortname2")});
+                                { clientShortname: mozL10n.get("clientShortname2") });
           var utils = loop.shared.utils;
           var isChrome = utils.isChrome(navigator.userAgent);
           var isFirefox = utils.isFirefox(navigator.userAgent);
           var isOpera = utils.isOpera(navigator.userAgent);
           var promptMediaMessageClasses = React.addons.classSet({
             "prompt-media-message": true,
             "chrome": isChrome,
             "firefox": isFirefox,
@@ -454,17 +454,17 @@ loop.standaloneRoomViews = (function(moz
         } else {
           this.setTitle(mozL10n.get("clientShortname2"));
         }
       }
 
       if (this.state.roomState !== ROOM_STATES.MEDIA_WAIT &&
           nextState.roomState === ROOM_STATES.MEDIA_WAIT) {
         this.props.dispatcher.dispatch(new sharedActions.SetupStreamElements({
-          publisherConfig: this.getDefaultPublisherConfig({publishVideo: true})
+          publisherConfig: this.getDefaultPublisherConfig({ publishVideo: true })
         }));
       }
 
       // UX don't want to surface these errors (as they would imply the user
       // needs to do something to fix them, when if they're having a conversation
       // they just need to connect). However, we do want there to be somewhere to
       // find reasonably easily, in case there's issues raised.
       if (!this.state.roomInfoFailure && nextState.roomInfoFailure) {
@@ -623,24 +623,24 @@ loop.standaloneRoomViews = (function(moz
             <StandaloneRoomInfoArea activeRoomStore={this.props.activeRoomStore}
               dispatcher={this.props.dispatcher}
               failureReason={this.state.failureReason}
               isFirefox={this.props.isFirefox}
               joinRoom={this.joinRoom}
               roomState={this.state.roomState}
               roomUsed={this.state.used} />
             <sharedViews.ConversationToolbar
-              audio={{enabled: !this.state.audioMuted,
-                      visible: this._roomIsActive()}}
+              audio={{ enabled: !this.state.audioMuted,
+                      visible: this._roomIsActive() }}
               dispatcher={this.props.dispatcher}
               hangup={this.leaveRoom}
               publishStream={this.publishStream}
               show={true}
-              video={{enabled: !this.state.videoMuted,
-                      visible: this._roomIsActive()}} />
+              video={{ enabled: !this.state.videoMuted,
+                      visible: this._roomIsActive() }} />
           </sharedViews.MediaLayoutView>
         </div>
       );
     }
   });
 
   var StandaloneOverlayWrapper = React.createClass({
     propTypes: {
--- a/browser/components/loop/standalone/content/js/webapp.js
+++ b/browser/components/loop/standalone/content/js/webapp.js
@@ -17,17 +17,17 @@ loop.webapp = (function(_, OT, mozL10n) 
   var WEBSOCKET_REASONS = loop.shared.utils.WEBSOCKET_REASONS;
 
   /**
    * Homepage view.
    */
   var HomeView = React.createClass({displayName: "HomeView",
     render: function() {
       return (
-        React.createElement("p", null, mozL10n.get("welcome", {clientShortname: mozL10n.get("clientShortname2")}))
+        React.createElement("p", null, mozL10n.get("welcome", { clientShortname: mozL10n.get("clientShortname2") }))
       );
     }
   });
 
   /**
    * Unsupported Browsers view.
    */
   var UnsupportedBrowserView = React.createClass({displayName: "UnsupportedBrowserView",
@@ -58,17 +58,17 @@ loop.webapp = (function(_, OT, mozL10n) 
     },
 
     render: function() {
       var unsupportedDeviceParams = {
         clientShortname: mozL10n.get("clientShortname2"),
         platform: mozL10n.get("unsupported_platform_" + this.props.platform)
       };
       var unsupportedLearnMoreText = mozL10n.get("unsupported_platform_learn_more_link",
-        {clientShortname: mozL10n.get("clientShortname2")});
+        { clientShortname: mozL10n.get("clientShortname2") });
 
       return (
         React.createElement("div", {className: "highlight-issue-box"}, 
           React.createElement("div", {className: "info-panel"}, 
             React.createElement("div", {className: "firefox-logo"}), 
             React.createElement("h1", null, mozL10n.get("unsupported_platform_heading")), 
             React.createElement("h4", null, mozL10n.get("unsupported_platform_message", unsupportedDeviceParams))
           ), 
@@ -89,17 +89,17 @@ loop.webapp = (function(_, OT, mozL10n) 
     },
 
     render: function() {
       if (this.props.isFirefox) {
         return null;
       }
       return (
         React.createElement("div", {className: "promote-firefox"}, 
-          React.createElement("h3", null, mozL10n.get("promote_firefox_hello_heading", {brandShortname: mozL10n.get("brandShortname")})), 
+          React.createElement("h3", null, mozL10n.get("promote_firefox_hello_heading", { brandShortname: mozL10n.get("brandShortname") })), 
           React.createElement("p", null, 
             React.createElement("a", {className: "btn btn-large btn-accept", 
                href: loop.config.downloadFirefoxUrl}, 
               mozL10n.get("get_firefox_button", {
                 brandShortname: mozL10n.get("brandShortname")
               })
             )
           )
--- a/browser/components/loop/standalone/content/js/webapp.jsx
+++ b/browser/components/loop/standalone/content/js/webapp.jsx
@@ -17,17 +17,17 @@ loop.webapp = (function(_, OT, mozL10n) 
   var WEBSOCKET_REASONS = loop.shared.utils.WEBSOCKET_REASONS;
 
   /**
    * Homepage view.
    */
   var HomeView = React.createClass({
     render: function() {
       return (
-        <p>{mozL10n.get("welcome", {clientShortname: mozL10n.get("clientShortname2")})}</p>
+        <p>{mozL10n.get("welcome", { clientShortname: mozL10n.get("clientShortname2") })}</p>
       );
     }
   });
 
   /**
    * Unsupported Browsers view.
    */
   var UnsupportedBrowserView = React.createClass({
@@ -58,17 +58,17 @@ loop.webapp = (function(_, OT, mozL10n) 
     },
 
     render: function() {
       var unsupportedDeviceParams = {
         clientShortname: mozL10n.get("clientShortname2"),
         platform: mozL10n.get("unsupported_platform_" + this.props.platform)
       };
       var unsupportedLearnMoreText = mozL10n.get("unsupported_platform_learn_more_link",
-        {clientShortname: mozL10n.get("clientShortname2")});
+        { clientShortname: mozL10n.get("clientShortname2") });
 
       return (
         <div className="highlight-issue-box">
           <div className="info-panel">
             <div className="firefox-logo" />
             <h1>{mozL10n.get("unsupported_platform_heading")}</h1>
             <h4>{mozL10n.get("unsupported_platform_message", unsupportedDeviceParams)}</h4>
           </div>
@@ -89,17 +89,17 @@ loop.webapp = (function(_, OT, mozL10n) 
     },
 
     render: function() {
       if (this.props.isFirefox) {
         return null;
       }
       return (
         <div className="promote-firefox">
-          <h3>{mozL10n.get("promote_firefox_hello_heading", {brandShortname: mozL10n.get("brandShortname")})}</h3>
+          <h3>{mozL10n.get("promote_firefox_hello_heading", { brandShortname: mozL10n.get("brandShortname") })}</h3>
           <p>
             <a className="btn btn-large btn-accept"
                href={loop.config.downloadFirefoxUrl}>
               {mozL10n.get("get_firefox_button", {
                 brandShortname: mozL10n.get("brandShortname")
               })}
             </a>
           </p>
--- a/browser/components/loop/test/desktop-local/conversation_test.js
+++ b/browser/components/loop/test/desktop-local/conversation_test.js
@@ -15,17 +15,17 @@ describe("loop.conversation", function()
 
   beforeEach(function() {
     sandbox = sinon.sandbox.create();
     setLoopPrefStub = sandbox.stub();
 
     navigator.mozLoop = {
       doNotDisturb: true,
       getStrings: function() {
-        return JSON.stringify({textContent: "fakeText"});
+        return JSON.stringify({ textContent: "fakeText" });
       },
       get locale() {
         return "en-US";
       },
       setLoopPref: setLoopPrefStub,
       getLoopPref: function(prefName) {
         switch (prefName) {
           case "debug.sdk":
@@ -44,17 +44,17 @@ describe("loop.conversation", function()
       get appVersionInfo() {
         return {
           version: "42",
           channel: "test",
           platform: "test"
         };
       },
       getAudioBlob: sinon.spy(function(name, callback) {
-        callback(null, new Blob([new ArrayBuffer(10)], {type: "audio/ogg"}));
+        callback(null, new Blob([new ArrayBuffer(10)], { type: "audio/ogg" }));
       }),
       getSelectedTabMetadata: function(callback) {
         callback({});
       }
     };
 
     fakeWindow = {
       navigator: { mozLoop: navigator.mozLoop },
@@ -169,18 +169,18 @@ describe("loop.conversation", function()
       });
     });
 
     afterEach(function() {
       ccView = undefined;
     });
 
     it("should display the RoomView for rooms", function() {
-      conversationAppStore.setStoreState({windowType: "room"});
-      activeRoomStore.setStoreState({roomState: ROOM_STATES.READY});
+      conversationAppStore.setStoreState({ windowType: "room" });
+      activeRoomStore.setStoreState({ roomState: ROOM_STATES.READY });
 
       ccView = mountTestComponent();
 
       TestUtils.findRenderedComponentWithType(ccView,
         loop.roomViews.DesktopRoomConversationView);
     });
 
     it("should display the RoomFailureView for failures", function() {
@@ -191,35 +191,35 @@ describe("loop.conversation", function()
 
       ccView = mountTestComponent();
 
       TestUtils.findRenderedComponentWithType(ccView,
         loop.roomViews.RoomFailureView);
     });
 
     it("should set the correct title when rendering feedback view", function() {
-      conversationAppStore.setStoreState({showFeedbackForm: true});
+      conversationAppStore.setStoreState({ showFeedbackForm: true });
 
       ccView = mountTestComponent();
 
       sinon.assert.calledWithExactly(mozL10nGet, "conversation_has_ended");
     });
 
     it("should render FeedbackView if showFeedbackForm state is true",
        function() {
-         conversationAppStore.setStoreState({showFeedbackForm: true});
+         conversationAppStore.setStoreState({ showFeedbackForm: true });
 
          ccView = mountTestComponent();
 
          TestUtils.findRenderedComponentWithType(ccView, FeedbackView);
        });
 
     it("should dispatch a ShowFeedbackForm action if timestamp is 0",
        function() {
-         conversationAppStore.setStoreState({feedbackTimestamp: 0});
+         conversationAppStore.setStoreState({ feedbackTimestamp: 0 });
          sandbox.stub(dispatcher, "dispatch");
 
          ccView = mountTestComponent();
 
          ccView.handleCallTerminated();
 
          sinon.assert.calledOnce(dispatcher.dispatch);
          sinon.assert.calledWithExactly(dispatcher.dispatch,
--- a/browser/components/loop/test/desktop-local/l10n_test.js
+++ b/browser/components/loop/test/desktop-local/l10n_test.js
@@ -27,15 +27,15 @@ describe("document.mozL10n", function() 
     document.mozL10n.initialize(fakeMozLoop);
   });
 
   it("should get a simple string", function() {
     expect(document.mozL10n.get("test")).eql("test");
   });
 
   it("should get a plural form", function() {
-    expect(document.mozL10n.get("plural", {num: 10})).eql("10 plural forms");
+    expect(document.mozL10n.get("plural", { num: 10 })).eql("10 plural forms");
   });
 
   it("should correctly get a plural form for num = 0", function() {
-    expect(document.mozL10n.get("plural", {num: 0})).eql("0 plural form");
+    expect(document.mozL10n.get("plural", { num: 0 })).eql("0 plural form");
   });
 });
--- a/browser/components/loop/test/desktop-local/panel_test.js
+++ b/browser/components/loop/test/desktop-local/panel_test.js
@@ -39,17 +39,17 @@ describe("loop.panel", function() {
     loop.shared.mixins.setRootObject(fakeWindow);
 
     notifications = new loop.shared.models.NotificationCollection();
 
     fakeMozLoop = navigator.mozLoop = {
       doNotDisturb: true,
       fxAEnabled: true,
       getStrings: function() {
-        return JSON.stringify({textContent: "fakeText"});
+        return JSON.stringify({ textContent: "fakeText" });
       },
       get locale() {
         return "en-US";
       },
       setLoopPref: sandbox.stub(),
       getLoopPref: function (prefName) {
         return "unseen";
       },
@@ -149,17 +149,17 @@ describe("loop.panel", function() {
           showTabButtons: true,
           mozLoop: fakeMozLoop,
           dispatcher: dispatcher,
           roomStore: roomStore
         }));
     }
 
     it("should hide the account entry when FxA is not enabled", function() {
-      navigator.mozLoop.userProfile = {email: "test@example.com"};
+      navigator.mozLoop.userProfile = { email: "test@example.com" };
       navigator.mozLoop.fxAEnabled = false;
 
       var view = TestUtils.renderIntoDocument(
         React.createElement(loop.panel.SettingsDropdown, {
           mozLoop: fakeMozLoop
         }));
 
       expect(view.getDOMNode().querySelectorAll(".icon-account"))
@@ -300,49 +300,49 @@ describe("loop.panel", function() {
           TestUtils.Simulate.click(view.getDOMNode()
                                      .querySelector(".entry-settings-signin"));
 
           sinon.assert.calledOnce(navigator.mozLoop.logInToFxA);
         });
       });
 
       it("should show a signout entry when user is authenticated", function() {
-        navigator.mozLoop.userProfile = {email: "test@example.com"};
+        navigator.mozLoop.userProfile = { email: "test@example.com" };
 
         var view = mountTestComponent();
 
         sinon.assert.calledWithExactly(document.mozL10n.get,
                                        "settings_menu_item_signout");
         sinon.assert.neverCalledWith(document.mozL10n.get,
                                      "settings_menu_item_signin");
       });
 
       it("should show an account entry when user is authenticated", function() {
-        navigator.mozLoop.userProfile = {email: "test@example.com"};
+        navigator.mozLoop.userProfile = { email: "test@example.com" };
 
         var view = mountTestComponent();
 
         sinon.assert.calledWithExactly(document.mozL10n.get,
                                        "settings_menu_item_settings");
       });
 
       it("should open the FxA settings when the account entry is clicked",
          function() {
-           navigator.mozLoop.userProfile = {email: "test@example.com"};
+           navigator.mozLoop.userProfile = { email: "test@example.com" };
 
            var view = mountTestComponent();
 
            TestUtils.Simulate.click(view.getDOMNode()
                                       .querySelector(".entry-settings-account"));
 
            sinon.assert.calledOnce(navigator.mozLoop.openFxASettings);
          });
 
       it("should sign out the user on click when authenticated", function() {
-        navigator.mozLoop.userProfile = {email: "test@example.com"};
+        navigator.mozLoop.userProfile = { email: "test@example.com" };
         var view = mountTestComponent();
 
         TestUtils.Simulate.click(view.getDOMNode()
                                    .querySelector(".entry-settings-signout"));
 
         sinon.assert.calledOnce(navigator.mozLoop.logOutFromFxA);
       });
 
@@ -570,17 +570,17 @@ describe("loop.panel", function() {
     describe("handleContextChevronClick", function() {
       var view;
 
       beforeEach(function() {
         // Stub to prevent warnings due to stores not being set up to handle
         // the actions we are triggering.
         sandbox.stub(dispatcher, "dispatch");
 
-        view = mountRoomEntry({room: new loop.store.Room(roomData)});
+        view = mountRoomEntry({ room: new loop.store.Room(roomData) });
       });
 
       // XXX Current version of React cannot use TestUtils.Simulate, please
       // enable when we upgrade.
       it.skip("should close the menu when you move out the cursor", function() {
         expect(view.refs.contextActions.state.showMenu).to.eql(false);
       });
 
@@ -626,25 +626,25 @@ describe("loop.panel", function() {
       });
 
       describe("OpenRoom", function() {
         it("should dispatch an OpenRoom action when button is clicked", function() {
           TestUtils.Simulate.click(roomEntry.refs.roomEntry.getDOMNode());
 
           sinon.assert.calledOnce(dispatcher.dispatch);
           sinon.assert.calledWithExactly(dispatcher.dispatch,
-            new sharedActions.OpenRoom({roomToken: roomData.roomToken}));
+            new sharedActions.OpenRoom({ roomToken: roomData.roomToken }));
         });
 
         it("should dispatch an OpenRoom action when callback is called", function() {
           roomEntry.handleClickEntry(fakeEvent);
 
           sinon.assert.calledOnce(dispatcher.dispatch);
           sinon.assert.calledWithExactly(dispatcher.dispatch,
-            new sharedActions.OpenRoom({roomToken: roomData.roomToken}));
+            new sharedActions.OpenRoom({ roomToken: roomData.roomToken }));
         });
 
         it("should call window.close", function() {
           roomEntry.handleClickEntry(fakeEvent);
 
           sinon.assert.calledOnce(fakeWindow.close);
         });
       });
@@ -730,17 +730,17 @@ describe("loop.panel", function() {
         });
         var updatedRoom = new loop.store.Room(_.extend({}, roomData, {
           decryptedContext: {
             roomName: "New room name"
           },
           ctime: new Date().getTime()
         }));
 
-        roomEntry.setProps({room: updatedRoom});
+        roomEntry.setProps({ room: updatedRoom });
 
         expect(
           roomEntry.getDOMNode().textContent)
         .eql("New room name");
       });
     });
   });
 
@@ -797,21 +797,21 @@ describe("loop.panel", function() {
 
       sinon.assert.calledOnce(dispatch);
       sinon.assert.calledWithExactly(dispatch, new sharedActions.GetAllRooms());
     });
 
     it("should close the panel once a room is created and there is no error", function() {
       var view = createTestComponent();
 
-      roomStore.setStoreState({pendingCreation: true});
+      roomStore.setStoreState({ pendingCreation: true });
 
       sinon.assert.notCalled(fakeWindow.close);
 
-      roomStore.setStoreState({pendingCreation: false});
+      roomStore.setStoreState({ pendingCreation: false });
 
       sinon.assert.calledOnce(fakeWindow.close);
     });
 
     it("should render the no rooms view when no rooms available", function() {
       var view = createTestComponent();
       var node = view.getDOMNode();
 
@@ -824,17 +824,17 @@ describe("loop.panel", function() {
       sinon.assert.calledWithExactly(document.mozL10n.get,
                                      "no_conversations_message_heading2");
       sinon.assert.calledWithExactly(document.mozL10n.get,
                                      "no_conversations_start_message2");
     });
 
     it("should display a loading animation when rooms are pending", function() {
       var view = createTestComponent();
-      roomStore.setStoreState({pendingInitialRetrieval: true});
+      roomStore.setStoreState({ pendingInitialRetrieval: true });
 
       expect(view.getDOMNode().querySelectorAll(".room-list-loading").length).to.eql(1);
     });
   });
 
   describe("loop.panel.NewRoomView", function() {
     var roomStore, dispatcher, fakeEmail, dispatch;
 
@@ -860,17 +860,17 @@ describe("loop.panel", function() {
           mozLoop: fakeMozLoop,
           pendingOperation: pendingOperation,
           userDisplayName: fakeEmail
         }));
     }
 
     it("should dispatch a CreateRoom action with context when clicking on the " +
        "Start a conversation button", function() {
-      fakeMozLoop.userProfile = {email: fakeEmail};
+      fakeMozLoop.userProfile = { email: fakeEmail };
       var favicon = "data:image/x-icon;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
       fakeMozLoop.getSelectedTabMetadata = function (callback) {
         callback({
           url: "http://invalid.com",
           description: "fakeSite",
           favicon: favicon,
           previews: ["fakeimage.png"]
         });
@@ -1009,23 +1009,23 @@ describe("loop.panel", function() {
 
       dispatcher = new loop.Dispatcher();
       sandbox.stub(dispatcher, "dispatch");
 
       view = createTestComponent();
     });
 
     it("should render ConversationDropdown if state.showMenu=true", function() {
-      view = createTestComponent({showMenu: true});
+      view = createTestComponent({ showMenu: true });
 
       expect(view.refs.menu).to.not.eql(undefined);
     });
 
     it("should not render ConversationDropdown by default", function() {
-      view = createTestComponent({showMenu: false});
+      view = createTestComponent({ showMenu: false });
 
       expect(view.refs.menu).to.eql(undefined);
     });
 
     it("should call toggleDropdownMenu after link is emailed", function() {
       view.handleEmailButtonClick(fakeEvent);
 
       sinon.assert.calledOnce(view.props.toggleDropdownMenu);
@@ -1052,17 +1052,17 @@ describe("loop.panel", function() {
         from: "panel"
       }));
     });
 
     it("should dispatch a delete action when callback is called", function() {
       view.handleDeleteButtonClick(fakeEvent);
 
       sinon.assert.calledWithExactly(dispatcher.dispatch,
-        new sharedActions.DeleteRoom({roomToken: roomData.roomToken}));
+        new sharedActions.DeleteRoom({ roomToken: roomData.roomToken }));
     });
 
     it("should trigger handleClickEntry when button is clicked", function() {
       TestUtils.Simulate.click(view.refs.callButton.getDOMNode());
 
       sinon.assert.calledOnce(view.props.handleClickEntry);
     });
   });
--- a/browser/components/loop/test/desktop-local/roomStore_test.js
+++ b/browser/components/loop/test/desktop-local/roomStore_test.js
@@ -197,25 +197,25 @@ describe("loop.store.RoomStore", functio
       });
     });
 
     describe("#findNextAvailableRoomNumber", function() {
       var fakeNameTemplate = "RoomWord {{conversationLabel}}";
 
       it("should find next available room number from an empty room list",
         function() {
-          store.setStoreState({rooms: []});
+          store.setStoreState({ rooms: [] });
 
           expect(store.findNextAvailableRoomNumber(fakeNameTemplate)).eql(1);
         });
 
       it("should find next available room number from a non empty room list",
         function() {
           store.setStoreState({
-            rooms: [{decryptedContext: {roomName: "RoomWord 1"}}]
+            rooms: [{ decryptedContext: { roomName: "RoomWord 1" } }]
           });
 
           expect(store.findNextAvailableRoomNumber(fakeNameTemplate)).eql(2);
         });
 
       it("should not be sensitive to initial list order", function() {
         store.setStoreState({
           rooms: [{
@@ -236,17 +236,17 @@ describe("loop.store.RoomStore", functio
     describe("#createRoom", function() {
       var fakeNameTemplate = "Conversation {{conversationLabel}}";
       var fakeLocalRoomId = "777";
       var fakeOwner = "fake@invalid";
       var fakeRoomCreationData;
 
       beforeEach(function() {
         sandbox.stub(dispatcher, "dispatch");
-        store.setStoreState({pendingCreation: false, rooms: []});
+        store.setStoreState({ pendingCreation: false, rooms: [] });
         fakeRoomCreationData = {
           nameTemplate: fakeNameTemplate
         };
       });
 
       it("should clear any existing room errors", function() {
         sandbox.stub(fakeMozLoop.rooms, "create");
 
@@ -254,17 +254,17 @@ describe("loop.store.RoomStore", functio
 
         sinon.assert.calledOnce(fakeNotifications.remove);
         sinon.assert.calledWithExactly(fakeNotifications.remove,
           "create-room-error");
       });
 
       it("should log a telemetry event when the operation with context is successful", function() {
         sandbox.stub(fakeMozLoop.rooms, "create", function(data, cb) {
-          cb(null, {roomToken: "fakeToken"});
+          cb(null, { roomToken: "fakeToken" });
         });
 
         fakeRoomCreationData.urls = [{
           location: "http://invalid.com",
           description: "fakeSite",
           thumbnail: "fakeimage.png"
         }];
 
@@ -318,17 +318,17 @@ describe("loop.store.RoomStore", functio
         store.createRoom(new sharedActions.CreateRoom(fakeRoomCreationData));
 
         expect(store.getStoreState().pendingCreation).eql(true);
       });
 
       it("should dispatch a CreatedRoom action once the operation is done",
         function() {
           sandbox.stub(fakeMozLoop.rooms, "create", function(data, cb) {
-            cb(null, {roomToken: "fakeToken"});
+            cb(null, { roomToken: "fakeToken" });
           });
 
           store.createRoom(new sharedActions.CreateRoom(fakeRoomCreationData));
 
           sinon.assert.calledOnce(dispatcher.dispatch);
           sinon.assert.calledWithExactly(dispatcher.dispatch,
             new sharedActions.CreatedRoom({
               roomToken: "fakeToken"
@@ -348,17 +348,17 @@ describe("loop.store.RoomStore", functio
           sinon.assert.calledWithExactly(dispatcher.dispatch,
             new sharedActions.CreateRoomError({
               error: err
             }));
         });
 
       it("should log a telemetry event when the operation is successful", function() {
         sandbox.stub(fakeMozLoop.rooms, "create", function(data, cb) {
-          cb(null, {roomToken: "fakeToken"});
+          cb(null, { roomToken: "fakeToken" });
         });
 
         store.createRoom(new sharedActions.CreateRoom(fakeRoomCreationData));
 
         sinon.assert.calledOnce(fakeMozLoop.telemetryAddValue);
         sinon.assert.calledWithExactly(fakeMozLoop.telemetryAddValue,
           "LOOP_ROOM_CREATE", 0);
       });
@@ -378,17 +378,17 @@ describe("loop.store.RoomStore", functio
    });
 
    describe("#createdRoom", function() {
       beforeEach(function() {
         sandbox.stub(dispatcher, "dispatch");
       });
 
       it("should switch the pendingCreation state flag to false", function() {
-        store.setStoreState({pendingCreation: true});
+        store.setStoreState({ pendingCreation: true });
 
         store.createdRoom(new sharedActions.CreatedRoom({
           roomToken: "fakeToken"
         }));
 
         expect(store.getStoreState().pendingCreation).eql(false);
       });
 
@@ -403,17 +403,17 @@ describe("loop.store.RoomStore", functio
             new sharedActions.OpenRoom({
               roomToken: "fakeToken"
             }));
         });
     });
 
     describe("#createRoomError", function() {
       it("should switch the pendingCreation state flag to false", function() {
-        store.setStoreState({pendingCreation: true});
+        store.setStoreState({ pendingCreation: true });
 
         store.createRoomError({
           error: new Error("fake")
         });
 
         expect(store.getStoreState().pendingCreation).eql(false);
       });
 
@@ -604,35 +604,35 @@ describe("loop.store.RoomStore", functio
         store.addSocialShareProvider(new sharedActions.AddSocialShareProvider());
 
         sinon.assert.calledOnce(fakeMozLoop.addSocialShareProvider);
       });
     });
 
     describe("#setStoreState", function() {
       it("should update store state data", function() {
-        store.setStoreState({pendingCreation: true});
+        store.setStoreState({ pendingCreation: true });
 
         expect(store.getStoreState().pendingCreation).eql(true);
       });
 
       it("should trigger a `change` event", function(done) {
         store.once("change", function() {
           done();
         });
 
-        store.setStoreState({pendingCreation: true});
+        store.setStoreState({ pendingCreation: true });
       });
 
       it("should trigger a `change:<prop>` event", function(done) {
         store.once("change:pendingCreation", function() {
           done();
         });
 
-        store.setStoreState({pendingCreation: true});
+        store.setStoreState({ pendingCreation: true });
       });
     });
 
     describe("#getAllRooms", function() {
       it("should fetch the room list from the MozLoop API", function() {
         fakeMozLoop.rooms.getAll = function(version, cb) {
           cb(null, fakeRoomList);
         };
@@ -708,49 +708,49 @@ describe("loop.store.RoomStore", functio
         });
         fakeStore = new loop.store.RoomStore(dispatcher, {
           mozLoop: fakeMozLoop,
           activeRoomStore: activeRoomStore
         });
       });
 
       it("should subscribe to substore changes", function() {
-        var fakeServerData = {fake: true};
+        var fakeServerData = { fake: true };
 
-        activeRoomStore.setStoreState({serverData: fakeServerData});
+        activeRoomStore.setStoreState({ serverData: fakeServerData });
 
         expect(fakeStore.getStoreState().activeRoom.serverData)
           .eql(fakeServerData);
       });
 
       it("should trigger a change event when the substore is updated",
         function(done) {
           fakeStore.once("change:activeRoom", function() {
             done();
           });
 
-          activeRoomStore.setStoreState({serverData: {}});
+          activeRoomStore.setStoreState({ serverData: {} });
         });
     });
   });
 
   describe("#openRoom", function() {
     var store, fakeMozLoop;
 
     beforeEach(function() {
       fakeMozLoop = {
         rooms: {
           open: sinon.spy()
         }
       };
-      store = new loop.store.RoomStore(dispatcher, {mozLoop: fakeMozLoop});
+      store = new loop.store.RoomStore(dispatcher, { mozLoop: fakeMozLoop });
     });
 
     it("should open the room via mozLoop", function() {
-      dispatcher.dispatch(new sharedActions.OpenRoom({roomToken: "42abc"}));
+      dispatcher.dispatch(new sharedActions.OpenRoom({ roomToken: "42abc" }));
 
       sinon.assert.calledOnce(fakeMozLoop.rooms.open);
       sinon.assert.calledWithExactly(fakeMozLoop.rooms.open, "42abc");
     });
   });
 
   describe("#updateRoomContext", function() {
     var store, fakeMozLoop, clock;
@@ -763,17 +763,17 @@ describe("loop.store.RoomStore", functio
             roomToken: "42abc",
             decryptedContext: {
               roomName: "sillier name"
             }
           }),
           update: null
         }
       };
-      store = new loop.store.RoomStore(dispatcher, {mozLoop: fakeMozLoop});
+      store = new loop.store.RoomStore(dispatcher, { mozLoop: fakeMozLoop });
     });
 
     afterEach(function() {
       clock.restore();
     });
 
     it("should rename the room via mozLoop", function() {
       fakeMozLoop.rooms.update = sinon.spy();
--- a/browser/components/loop/test/desktop-local/roomViews_test.js
+++ b/browser/components/loop/test/desktop-local/roomViews_test.js
@@ -19,17 +19,17 @@ describe("loop.roomViews", function () {
 
   beforeEach(function() {
     sandbox = sinon.sandbox.create();
 
     dispatcher = new loop.Dispatcher();
 
     fakeMozLoop = {
       getAudioBlob: sinon.spy(function(name, callback) {
-        callback(null, new Blob([new ArrayBuffer(10)], {type: "audio/ogg"}));
+        callback(null, new Blob([new ArrayBuffer(10)], { type: "audio/ogg" }));
       }),
       getLoopPref: sinon.stub(),
       getSelectedTabMetadata: sinon.stub().callsArgWith(0, {
         favicon: favicon,
         previews: [],
         title: ""
       }),
       openURL: sinon.stub(),
@@ -99,43 +99,43 @@ describe("loop.roomViews", function () {
     view = null;
   });
 
   describe("ActiveRoomStoreMixin", function() {
     it("should merge initial state", function() {
       var TestView = React.createClass({
         mixins: [loop.roomViews.ActiveRoomStoreMixin],
         getInitialState: function() {
-          return {foo: "bar"};
+          return { foo: "bar" };
         },
         render: function() { return React.DOM.div(); }
       });
 
       var testView = TestUtils.renderIntoDocument(
         React.createElement(TestView, {
           roomStore: roomStore
         }));
 
-      var expectedState = _.extend({foo: "bar", savingContext: false},
+      var expectedState = _.extend({ foo: "bar", savingContext: false },
         activeRoomStore.getInitialStoreState());
 
       expect(testView.state).eql(expectedState);
     });
 
     it("should listen to store changes", function() {
       var TestView = React.createClass({
         mixins: [loop.roomViews.ActiveRoomStoreMixin],
         render: function() { return React.DOM.div(); }
       });
       var testView = TestUtils.renderIntoDocument(
         React.createElement(TestView, {
           roomStore: roomStore
         }));
 
-      activeRoomStore.setStoreState({roomState: ROOM_STATES.READY});
+      activeRoomStore.setStoreState({ roomState: ROOM_STATES.READY });
 
       expect(testView.state.roomState).eql(ROOM_STATES.READY);
     });
   });
 
   describe("RoomFailureView", function() {
     var fakeAudio;
 
@@ -341,17 +341,17 @@ describe("loop.roomViews", function () {
       return TestUtils.renderIntoDocument(
         React.createElement(loop.roomViews.DesktopRoomConversationView, props));
     }
 
     it("should dispatch a setMute action when the audio mute button is pressed",
       function() {
         view = mountTestComponent();
 
-        view.setState({audioMuted: true});
+        view.setState({ audioMuted: true });
 
         var muteBtn = view.getDOMNode().querySelector(".btn-mute-audio");
 
         React.addons.TestUtils.Simulate.click(muteBtn);
 
         sinon.assert.calledWithMatch(dispatcher.dispatch,
           sinon.match.hasOwn("name", "setMute"));
         sinon.assert.calledWithMatch(dispatcher.dispatch,
@@ -359,54 +359,54 @@ describe("loop.roomViews", function () {
         sinon.assert.calledWithMatch(dispatcher.dispatch,
           sinon.match.hasOwn("type", "audio"));
       });
 
     it("should dispatch a setMute action when the video mute button is pressed",
       function() {
         view = mountTestComponent();
 
-        view.setState({videoMuted: false});
+        view.setState({ videoMuted: false });
 
         var muteBtn = view.getDOMNode().querySelector(".btn-mute-video");
 
         React.addons.TestUtils.Simulate.click(muteBtn);
 
         sinon.assert.calledWithMatch(dispatcher.dispatch,
           sinon.match.hasOwn("name", "setMute"));
         sinon.assert.calledWithMatch(dispatcher.dispatch,
           sinon.match.hasOwn("enabled", false));
         sinon.assert.calledWithMatch(dispatcher.dispatch,
           sinon.match.hasOwn("type", "video"));
       });
 
     it("should set the mute button as mute off", function() {
       view = mountTestComponent();
 
-      view.setState({videoMuted: false});
+      view.setState({ videoMuted: false });
 
       var muteBtn = view.getDOMNode().querySelector(".btn-mute-video");
 
       expect(muteBtn.classList.contains("muted")).eql(false);
     });
 
     it("should set the mute button as mute on", function() {
       view = mountTestComponent();
 
-      view.setState({audioMuted: true});
+      view.setState({ audioMuted: true });
 
       var muteBtn = view.getDOMNode().querySelector(".btn-mute-audio");
 
       expect(muteBtn.classList.contains("muted")).eql(true);
     });
 
     it("should dispatch a `StartScreenShare` action when sharing is not active and the screen share button is pressed", function() {
       view = mountTestComponent();
 
-      view.setState({screenSharingState: SCREEN_SHARE_STATES.INACTIVE});
+      view.setState({ screenSharingState: SCREEN_SHARE_STATES.INACTIVE });
 
       var muteBtn = view.getDOMNode().querySelector(".btn-mute-video");
 
       React.addons.TestUtils.Simulate.click(muteBtn);
 
       sinon.assert.calledWithMatch(dispatcher.dispatch,
         sinon.match.hasOwn("name", "setMute"));
     });
@@ -414,39 +414,39 @@ describe("loop.roomViews", function () {
     describe("#componentWillUpdate", function() {
       function expectActionDispatched(component) {
         sinon.assert.calledOnce(dispatcher.dispatch);
         sinon.assert.calledWithExactly(dispatcher.dispatch,
           sinon.match.instanceOf(sharedActions.SetupStreamElements));
       }
 
       it("should dispatch a `SetupStreamElements` action when the MEDIA_WAIT state is entered", function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.READY});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.READY });
           var component = mountTestComponent();
 
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.MEDIA_WAIT});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.MEDIA_WAIT });
 
           expectActionDispatched(component);
         });
 
       it("should dispatch a `SetupStreamElements` action on MEDIA_WAIT state is re-entered", function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.ENDED});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.ENDED });
           var component = mountTestComponent();
 
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.MEDIA_WAIT});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.MEDIA_WAIT });
 
           expectActionDispatched(component);
         });
     });
 
     describe("#render", function() {
       it("should set document.title to store.serverData.roomName", function() {
         mountTestComponent();
 
-        activeRoomStore.setStoreState({roomName: "fakeName"});
+        activeRoomStore.setStoreState({ roomName: "fakeName" });
 
         expect(fakeWindow.document.title).to.equal("fakeName");
       });
 
       it("should render the RoomFailureView if the roomState is `FAILED`",
         function() {
           activeRoomStore.setStoreState({
             failureReason: FAILURE_DETAILS.UNKNOWN,
@@ -469,28 +469,28 @@ describe("loop.roomViews", function () {
           view = mountTestComponent();
 
           TestUtils.findRenderedComponentWithType(view,
             loop.roomViews.RoomFailureView);
         });
 
       it("should render the DesktopRoomInvitationView if roomState is `JOINED`",
         function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINED});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINED });
 
           view = mountTestComponent();
 
           expect(TestUtils.findRenderedComponentWithType(view,
             loop.roomViews.DesktopRoomInvitationView).getDOMNode()).to.not.eql(null);
         });
 
       it("should render the DesktopRoomInvitationView if roomState is `JOINED` with just owner",
         function() {
           activeRoomStore.setStoreState({
-            participants: [{owner: true}],
+            participants: [{ owner: true }],
             roomState: ROOM_STATES.JOINED
           });
 
           view = mountTestComponent();
 
           expect(TestUtils.findRenderedComponentWithType(view,
             loop.roomViews.DesktopRoomInvitationView).getDOMNode()).to.not.eql(null);
         });
@@ -508,31 +508,31 @@ describe("loop.roomViews", function () {
             loop.roomViews.DesktopRoomConversationView);
           expect(TestUtils.findRenderedComponentWithType(view,
             loop.roomViews.DesktopRoomInvitationView).getDOMNode()).to.eql(null);
         });
 
       it("should render the DesktopRoomConversationView if roomState is `JOINED` with participants",
         function() {
           activeRoomStore.setStoreState({
-            participants: [{owner: true}, {}],
+            participants: [{ owner: true }, {}],
             roomState: ROOM_STATES.JOINED
           });
 
           view = mountTestComponent();
 
           TestUtils.findRenderedComponentWithType(view,
             loop.roomViews.DesktopRoomConversationView);
           expect(TestUtils.findRenderedComponentWithType(view,
             loop.roomViews.DesktopRoomInvitationView).getDOMNode()).to.eql(null);
         });
 
       it("should render the DesktopRoomConversationView if roomState is `HAS_PARTICIPANTS`",
         function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.HAS_PARTICIPANTS});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.HAS_PARTICIPANTS });
 
           view = mountTestComponent();
 
           TestUtils.findRenderedComponentWithType(view,
             loop.roomViews.DesktopRoomConversationView);
           expect(TestUtils.findRenderedComponentWithType(view,
             loop.roomViews.DesktopRoomInvitationView).getDOMNode()).to.eql(null);
         });
@@ -836,17 +836,17 @@ describe("loop.roomViews", function () {
 
         roomNameBox = view.getDOMNode().querySelector(".room-context-name");
       });
 
       it("should dispatch a UpdateRoomContext action when the save button is clicked",
         function() {
           React.addons.TestUtils.Simulate.change(roomNameBox, { target: {
             value: "reallyFake"
-          }});
+          } });
 
           React.addons.TestUtils.Simulate.click(view.getDOMNode().querySelector(".button-accept"));
 
           sinon.assert.calledOnce(dispatcher.dispatch);
           sinon.assert.calledWithExactly(dispatcher.dispatch,
             new sharedActions.UpdateRoomContext({
               roomToken: "fakeToken",
               newRoomName: "reallyFake",
@@ -855,19 +855,19 @@ describe("loop.roomViews", function () {
               newRoomThumbnail: fakeContextURL.thumbnail
             }));
         });
 
       it("should dispatch a UpdateRoomContext action when Enter key is pressed",
         function() {
           React.addons.TestUtils.Simulate.change(roomNameBox, { target: {
             value: "reallyFake"
-          }});
+          } });
 
-          TestUtils.Simulate.keyDown(roomNameBox, {key: "Enter", which: 13});
+          TestUtils.Simulate.keyDown(roomNameBox, { key: "Enter", which: 13 });
 
           sinon.assert.calledOnce(dispatcher.dispatch);
           sinon.assert.calledWithExactly(dispatcher.dispatch,
             new sharedActions.UpdateRoomContext({
               roomToken: "fakeToken",
               newRoomName: "reallyFake",
               newRoomDescription: fakeContextURL.description,
               newRoomURL: fakeContextURL.location,
--- a/browser/components/loop/test/mochitest/browser_CardDavImporter.js
+++ b/browser/components/loop/test/mochitest/browser_CardDavImporter.js
@@ -1,14 +1,14 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
-const {CardDavImporter} = Cu.import("resource:///modules/loop/CardDavImporter.jsm", {});
+const { CardDavImporter } = Cu.import("resource:///modules/loop/CardDavImporter.jsm", {});
 
 const kAuth = {
   "method": "basic",
   "user": "username",
   "password": "p455w0rd"
 };
 
 
@@ -157,17 +157,17 @@ const monkeyPatchImporter = function(imp
           break;
         case "REPORT https://example.com/carddav/abook/ 1":
           responseXML = xmlParser.parseFromString(listReportMultiget, "text/xml");
           break;
         default:
           reject(new Error("404 Not Found"));
           return;
       }
-      resolve({"responseXML": responseXML});
+      resolve({ "responseXML": responseXML });
     });
   }.bind(importer);
   return importer;
 };
 
 add_task(function* test_CardDavImport() {
   let importer = monkeyPatchImporter(new CardDavImporter());
   yield new Promise((resolve, reject) => {
--- a/browser/components/loop/test/mochitest/browser_GoogleImporter.js
+++ b/browser/components/loop/test/mochitest/browser_GoogleImporter.js
@@ -1,14 +1,14 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
-const {GoogleImporter} = Cu.import("resource:///modules/loop/GoogleImporter.jsm", {});
+const { GoogleImporter } = Cu.import("resource:///modules/loop/GoogleImporter.jsm", {});
 
 var importer = new GoogleImporter();
 
 function promiseImport() {
   return new Promise(function(resolve, reject) {
     importer.startImport({}, function(err, stats) {
       if (err) {
         reject(err);
--- a/browser/components/loop/test/mochitest/browser_LoopContacts.js
+++ b/browser/components/loop/test/mochitest/browser_LoopContacts.js
@@ -1,15 +1,15 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
-const {LoopContacts} = Cu.import("resource:///modules/loop/LoopContacts.jsm", {});
-const {LoopStorage} = Cu.import("resource:///modules/loop/LoopStorage.jsm", {});
+const { LoopContacts } = Cu.import("resource:///modules/loop/LoopContacts.jsm", {});
+const { LoopStorage } = Cu.import("resource:///modules/loop/LoopStorage.jsm", {});
 
 XPCOMUtils.defineLazyServiceGetter(this, "uuidgen",
                                    "@mozilla.org/uuid-generator;1",
                                    "nsIUUIDGenerator");
 
 const kContacts = [{
   id: 1,
   name: ["Ally Avocado"],
--- a/browser/components/loop/test/mochitest/browser_LoopRooms_channel.js
+++ b/browser/components/loop/test/mochitest/browser_LoopRooms_channel.js
@@ -3,18 +3,18 @@
 
 /*
  * This file contains tests for checking the channel from the standalone to
  * LoopRooms works for checking if rooms can be opened within the conversation
  * window.
  */
 "use strict";
 
-var {WebChannel} = Cu.import("resource://gre/modules/WebChannel.jsm", {});
-var {Chat} = Cu.import("resource:///modules/Chat.jsm", {});
+var { WebChannel } = Cu.import("resource://gre/modules/WebChannel.jsm", {});
+var { Chat } = Cu.import("resource:///modules/Chat.jsm", {});
 
 const TEST_URI =
   "example.com/browser/browser/components/loop/test/mochitest/test_loopLinkClicker_channel.html";
 const TEST_URI_GOOD = Services.io.newURI("https://" + TEST_URI, null, null);
 const TEST_URI_BAD = Services.io.newURI("http://" + TEST_URI, null, null);
 
 const ROOM_TOKEN = "fake1234";
 const LINKCLICKER_URL_PREFNAME = "loop.linkClicker.url";
--- a/browser/components/loop/test/mochitest/browser_fxa_login.js
+++ b/browser/components/loop/test/mochitest/browser_fxa_login.js
@@ -281,17 +281,17 @@ add_task(function* basicAuthorizationAnd
   };
   yield promiseOAuthParamsSetup(BASE_URL, params);
 
   info("registering");
   mockPushHandler.registrationPushURL = "https://localhost/pushUrl/guest";
   yield MozLoopService.promiseRegisteredWithServers();
 
   let statusChangedPromise = promiseObserverNotified("loop-status-changed");
-  yield loadLoopPanel({stayOnline: true});
+  yield loadLoopPanel({ stayOnline: true });
   yield statusChangedPromise;
   let loopDoc = document.getElementById("loop-panel-iframe").contentDocument;
   let accountLogin = loopDoc.getElementsByClassName("signin-link")[0];
   let visibleEmail = loopDoc.getElementsByClassName("user-identity");
   is(visibleEmail.length, 0, "No email should be displayed when logged out");
   is(accountLogin.textContent, "Sign In or Sign Up", "Login/Signup links when logged out");
   is(MozLoopService.userProfile, null, "profile should be null before log-in");
   let loopButton = document.getElementById("loop-button");
@@ -314,17 +314,17 @@ add_task(function* basicAuthorizationAnd
 
   let registrationResponse = yield promiseOAuthGetRegistration(BASE_URL);
   is(registrationResponse.response.simplePushURLs.rooms, "https://localhost/pushUrl/fxa-rooms",
      "Check registered push URL");
 
   let loopPanel = document.getElementById("loop-notification-panel");
   loopPanel.hidePopup();
   statusChangedPromise = promiseObserverNotified("loop-status-changed");
-  yield loadLoopPanel({stayOnline: true});
+  yield loadLoopPanel({ stayOnline: true });
   yield statusChangedPromise;
   is(loopButton.getAttribute("state"), "", "state of loop button should return to empty after panel is opened");
   loopPanel.hidePopup();
 
   info("logout");
   yield MozLoopService.logOutFromFxA();
   checkLoggedOutState();
   registrationResponse = yield promiseOAuthGetRegistration(BASE_URL);
--- a/browser/components/loop/test/mochitest/browser_mozLoop_sharingListeners.js
+++ b/browser/components/loop/test/mochitest/browser_mozLoop_sharingListeners.js
@@ -1,17 +1,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 /*
  * This file contains tests for the window.LoopUI active tab trackers.
  */
 "use strict";
 
-const {injectLoopAPI} = Cu.import("resource:///modules/loop/MozLoopAPI.jsm", {});
+const { injectLoopAPI } = Cu.import("resource:///modules/loop/MozLoopAPI.jsm", {});
 gMozLoopAPI = injectLoopAPI({});
 
 var handlers = [
   {
     resolve: null,
     windowId: null,
     listener: function(err, windowId) {
       handlers[0].windowId = windowId;
--- a/browser/components/loop/test/mochitest/browser_mozLoop_socialShare.js
+++ b/browser/components/loop/test/mochitest/browser_mozLoop_socialShare.js
@@ -4,17 +4,17 @@
 /**
  * This is an integration test from navigator.mozLoop through to the end
  * effects - rather than just testing MozLoopAPI alone.
  */
 
 "use strict";
 
 Cu.import("resource://gre/modules/Promise.jsm");
-const {SocialService} = Cu.import("resource://gre/modules/SocialService.jsm", {});
+const { SocialService } = Cu.import("resource://gre/modules/SocialService.jsm", {});
 
 add_task(loadLoopPanel);
 
 const kShareProvider = {
   name: "provider 1",
   origin: "https://example.com",
   iconURL: "https://example.com/browser/browser/base/content/test/general/moz.png",
   shareURL: "https://example.com/browser/browser/base/content/test/social/social_sidebar_empty.html"
--- a/browser/components/loop/test/mochitest/browser_toolbarbutton.js
+++ b/browser/components/loop/test/mochitest/browser_toolbarbutton.js
@@ -3,17 +3,17 @@
 
 /**
  * Test the toolbar button states.
  */
 
 "use strict";
 
 Components.utils.import("resource://gre/modules/Promise.jsm", this);
-const {LoopRoomsInternal} = Components.utils.import("resource:///modules/loop/LoopRooms.jsm", {});
+const { LoopRoomsInternal } = Components.utils.import("resource:///modules/loop/LoopRooms.jsm", {});
 Services.prefs.setBoolPref("loop.gettingStarted.seen", true);
 
 const fxASampleToken = {
   token_type: "bearer",
   access_token: "1bad3e44b12f77a88fe09f016f6a37c42e40f974bc7a8b432bb0d2f0e37e1752",
   scope: "profile"
 };
 
@@ -122,33 +122,33 @@ add_task(function* test_active() {
   MozLoopServiceInternal.notifyStatusChanged();
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("state"), "", "Check button is in default state");
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("tooltiptext"), "Start a conversation", "Check button has default tooltiptext");
 });
 
 add_task(function* test_room_participants() {
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("state"), "", "Check button is in default state");
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("tooltiptext"), "Start a conversation", "Check button has default tooltiptext");
-  let roomsCache = new Map([["test_room", {participants: [{displayName: "hugh", id: "008", owner: true}]}]]);
+  let roomsCache = new Map([["test_room", { participants: [{ displayName: "hugh", id: "008", owner: true }] }]]);
   LoopRooms._setRoomsCache(roomsCache);
   MozLoopServiceInternal.notifyStatusChanged();
   // Since we're changing the rooms map directly, we're expecting it to be a synchronous operation.
   // But Promises have the inherent property of then-ables being async so even though the operation returns immediately,
   // because the cache is hit, the promise won't be resolved until after the next tick.
   // And that's what the line below does, waits until the next tick
   yield new Promise(resolve => executeSoon(resolve));
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("state"), "active", "Check button is in active state");
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("tooltiptext"), "Active conversation", "Check button has active tooltiptext");
-  roomsCache.set("test_room", {participants: [{displayName: "hugh", id: "008", owner: false}]});
+  roomsCache.set("test_room", { participants: [{ displayName: "hugh", id: "008", owner: false }] });
   LoopRooms._setRoomsCache(roomsCache);
   MozLoopServiceInternal.notifyStatusChanged();
   yield new Promise(resolve => executeSoon(resolve));
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("state"), "active", "Check button is in active state");
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("tooltiptext"), "Someone is waiting for you in a conversation", "Check button has participantswaiting tooltiptext");
-  roomsCache.set("test_room", {participants: []});
+  roomsCache.set("test_room", { participants: [] });
   LoopRooms._setRoomsCache(roomsCache);
   MozLoopServiceInternal.notifyStatusChanged();
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("state"), "", "Check button is in default state");
   Assert.strictEqual(LoopUI.toolbarButton.node.getAttribute("tooltiptext"), "Start a conversation", "Check button has default tooltiptext");
   LoopRooms._setRoomsCache();
 });
 
 add_task(function* test_panelToggle_on_click() {
--- a/browser/components/loop/test/mochitest/head.js
+++ b/browser/components/loop/test/mochitest/head.js
@@ -4,17 +4,17 @@
 "use strict";
 
 const HAWK_TOKEN_LENGTH = 64;
 const {
   LOOP_SESSION_TYPE,
   MozLoopServiceInternal,
   MozLoopService
 } = Cu.import("resource:///modules/loop/MozLoopService.jsm", {});
-const {LoopRooms} = Cu.import("resource:///modules/loop/LoopRooms.jsm", {});
+const { LoopRooms } = Cu.import("resource:///modules/loop/LoopRooms.jsm", {});
 
 // Cache this value only once, at the beginning of a
 // test run, so that it doesn't pick up the offline=true
 // if offline mode is requested multiple times in a test run.
 const WAS_OFFLINE = Services.io.offline;
 
 
 var gMozLoopAPI;
@@ -181,17 +181,17 @@ function promiseDeletedOAuthParams(baseU
   });
 }
 
 function promiseObserverNotified(aTopic, aExpectedData = null) {
   return new Promise((resolve, reject) => {
     Services.obs.addObserver(function onNotification(aSubject, topic, aData) {
       Services.obs.removeObserver(onNotification, topic);
       is(aData, aExpectedData, "observer data should match expected data");
-      resolve({subject: aSubject, data: aData});
+      resolve({ subject: aSubject, data: aData });
     }, aTopic, false);
   });
 }
 
 /**
  * Get the last registration on the test server.
  */
 function promiseOAuthGetRegistration(baseURL) {
--- a/browser/components/loop/test/shared/activeRoomStore_test.js
+++ b/browser/components/loop/test/shared/activeRoomStore_test.js
@@ -78,17 +78,17 @@ describe("loop.store.ActiveRoomStore", f
     it("should throw an error if mozLoop is missing", function() {
       expect(function() {
         new loop.store.ActiveRoomStore(dispatcher);
       }).to.Throw(/mozLoop/);
     });
 
     it("should throw an error if sdkDriver is missing", function() {
       expect(function() {
-        new loop.store.ActiveRoomStore(dispatcher, {mozLoop: {}});
+        new loop.store.ActiveRoomStore(dispatcher, { mozLoop: {} });
       }).to.Throw(/sdkDriver/);
     });
   });
 
   describe("#roomFailure", function() {
     var fakeError;
 
     beforeEach(function() {
@@ -166,17 +166,17 @@ describe("loop.store.ActiveRoomStore", f
         error: fakeError,
         failedJoinRequest: false
       }));
 
       sinon.assert.calledOnce(fakeMultiplexGum.reset);
     });
 
     it("should set screen sharing inactive", function() {
-      store.setStoreState({windowId: "1234"});
+      store.setStoreState({ windowId: "1234" });
 
       store.roomFailure(new sharedActions.RoomFailure({
         error: fakeError,
         failedJoinRequest: false
       }));
 
       sinon.assert.calledOnce(fakeMozLoop.setScreenShareState);
       sinon.assert.calledWithExactly(fakeMozLoop.setScreenShareState, "1234", false);
@@ -817,21 +817,21 @@ describe("loop.store.ActiveRoomStore", f
       var state = store.getStoreState();
       expect(state.socialShareProviders)
         .eql(fakeSocialShareInfo.socialShareProviders);
     });
   });
 
   describe("#joinRoom", function() {
     beforeEach(function() {
-      store.setStoreState({roomState: ROOM_STATES.READY});
+      store.setStoreState({ roomState: ROOM_STATES.READY });
     });
 
     it("should reset failureReason", function() {
-      store.setStoreState({failureReason: "Test"});
+      store.setStoreState({ failureReason: "Test" });
 
       store.joinRoom();
 
       expect(store.getStoreState().failureReason).eql(undefined);
     });
 
     describe("Standalone Handles Room", function() {
       it("should dispatch a MetricsLogJoinRoom action", function() {
@@ -988,17 +988,17 @@ describe("loop.store.ActiveRoomStore", f
             reason: FAILURE_DETAILS.ROOM_ALREADY_OPEN
           }));
       });
     });
   });
 
   describe("#gotMediaPermission", function() {
     beforeEach(function() {
-      store.setStoreState({roomToken: "tokenFake"});
+      store.setStoreState({ roomToken: "tokenFake" });
     });
 
     it("should set the room state to JOINING", function() {
       store.gotMediaPermission();
 
       expect(store.getStoreState().roomState).eql(ROOM_STATES.JOINING);
     });
 
@@ -1155,17 +1155,17 @@ describe("loop.store.ActiveRoomStore", f
         sinon.assert.calledOnce(fakeMozLoop.rooms.refreshMembership);
         sinon.assert.calledWith(fakeMozLoop.rooms.refreshMembership,
           "fakeToken", "12563478");
     });
 
     it("should call mozLoop.rooms.refreshMembership before the next expiresTime",
       function() {
         fakeMozLoop.rooms.refreshMembership.callsArgWith(2,
-          null, {expires: 40});
+          null, { expires: 40 });
 
         store.joinedRoom(new sharedActions.JoinedRoom(fakeJoinedData));
 
         // Clock tick for the first expiry time (which
         // sets up the refreshMembership).
         sandbox.clock.tick(fakeJoinedData.expires * 1000);
 
         // Clock tick for expiry time in the refresh membership response.
@@ -1227,17 +1227,17 @@ describe("loop.store.ActiveRoomStore", f
 
     it("should reset the multiplexGum", function() {
       store.connectionFailure(connectionFailureAction);
 
       sinon.assert.calledOnce(fakeMultiplexGum.reset);
     });
 
     it("should set screen sharing inactive", function() {
-      store.setStoreState({windowId: "1234"});
+      store.setStoreState({ windowId: "1234" });
 
       store.connectionFailure(connectionFailureAction);
 
       sinon.assert.calledOnce(fakeMozLoop.setScreenShareState);
       sinon.assert.calledWithExactly(fakeMozLoop.setScreenShareState, "1234", false);
     });
 
     it("should disconnect from the servers via the sdk", function() {
@@ -1302,43 +1302,43 @@ describe("loop.store.ActiveRoomStore", f
 
       sinon.assert.notCalled(fakeMultiplexGum.reset);
       sinon.assert.notCalled(fakeSdkDriver.disconnectSession);
     });
   });
 
   describe("#setMute", function() {
     it("should save the mute state for the audio stream", function() {
-      store.setStoreState({audioMuted: false});
+      store.setStoreState({ audioMuted: false });
 
       store.setMute(new sharedActions.SetMute({
         type: "audio",
         enabled: true
       }));
 
       expect(store.getStoreState().audioMuted).eql(false);
     });
 
     it("should save the mute state for the video stream", function() {
-      store.setStoreState({videoMuted: true});
+      store.setStoreState({ videoMuted: true });
 
       store.setMute(new sharedActions.SetMute({
         type: "video",
         enabled: false
       }));
 
       expect(store.getStoreState().videoMuted).eql(true);
     });
   });
 
   describe("#mediaStreamCreated", function() {
     var fakeStreamElement;
 
     beforeEach(function() {
-      fakeStreamElement = {name: "fakeStreamElement"};
+      fakeStreamElement = { name: "fakeStreamElement" };
     });
 
     it("should add a local video object to the store", function() {
       expect(store.getStoreState()).to.not.have.property("localSrcMediaElement");
 
       store.mediaStreamCreated(new sharedActions.MediaStreamCreated({
         hasVideo: false,
         isLocal: true,
@@ -1394,17 +1394,17 @@ describe("loop.store.ActiveRoomStore", f
       expect(store.getStoreState().remoteVideoEnabled).eql(true);
     });
   });
 
   describe("#mediaStreamDestroyed", function() {
     var fakeStreamElement;
 
     beforeEach(function() {
-      fakeStreamElement = {name: "fakeStreamElement"};
+      fakeStreamElement = { name: "fakeStreamElement" };
 
       store.setStoreState({
         localSrcMediaElement: fakeStreamElement,
         remoteSrcMediaElement: fakeStreamElement
       });
     });
 
     it("should clear the local video object", function() {
@@ -1457,17 +1457,17 @@ describe("loop.store.ActiveRoomStore", f
       store.mediaConnected();
 
       expect(store.getStoreState().mediaConnected).eql(true);
     });
   });
 
   describe("#screenSharingState", function() {
     beforeEach(function() {
-      store.setStoreState({windowId: "1234"});
+      store.setStoreState({ windowId: "1234" });
     });
 
     it("should save the state", function() {
       store.screenSharingState(new sharedActions.ScreenSharingState({
         state: SCREEN_SHARE_STATES.ACTIVE
       }));
 
       expect(store.getStoreState().screenSharingState).eql(SCREEN_SHARE_STATES.ACTIVE);
@@ -1497,17 +1497,17 @@ describe("loop.store.ActiveRoomStore", f
       store.receivingScreenShare(new sharedActions.ReceivingScreenShare({
         receiving: true
       }));
 
       expect(store.getStoreState().receivingScreenShare).eql(true);
     });
 
     it("should add a screenShareMediaElement to the store when sharing is active", function() {
-      var fakeStreamElement = {name: "fakeStreamElement"};
+      var fakeStreamElement = { name: "fakeStreamElement" };
       expect(store.getStoreState()).to.not.have.property("screenShareMediaElement");
 
       store.receivingScreenShare(new sharedActions.ReceivingScreenShare({
         receiving: true,
         srcMediaElement: fakeStreamElement
       }));
 
       expect(store.getStoreState()).to.have.property("screenShareMediaElement",
@@ -1527,27 +1527,27 @@ describe("loop.store.ActiveRoomStore", f
       }));
 
       expect(store.getStoreState().screenShareMediaElement).eql(null);
     });
 
     it("should delete the screen remote video dimensions if screen sharing is not active", function() {
       store.setStoreState({
         remoteVideoDimensions: {
-          screen: {fake: 10},
-          camera: {fake: 20}
+          screen: { fake: 10 },
+          camera: { fake: 20 }
         }
       });
 
       store.receivingScreenShare(new sharedActions.ReceivingScreenShare({
         receiving: false
       }));
 
       expect(store.getStoreState().remoteVideoDimensions).eql({
-        camera: {fake: 20}
+        camera: { fake: 20 }
       });
     });
   });
 
   describe("#startScreenShare", function() {
     it("should set the state to 'pending'", function() {
       store.startScreenShare(new sharedActions.StartScreenShare({
         type: "window"
@@ -1698,29 +1698,29 @@ describe("loop.store.ActiveRoomStore", f
 
       store.remotePeerDisconnected();
 
       expect(store.getStoreState().remoteSrcMediaElement).eql(null);
     });
 
     it("should remove non-owner participants", function() {
       store.setStoreState({
-        participants: [{owner: true}, {}]
+        participants: [{ owner: true }, {}]
       });
 
       store.remotePeerDisconnected();
 
       var participants = store.getStoreState().participants;
       expect(participants).to.have.length.of(1);
       expect(participants[0].owner).eql(true);
     });
 
     it("should keep the owner participant", function() {
       store.setStoreState({
-        participants: [{owner: true}]
+        participants: [{ owner: true }]
       });
 
       store.remotePeerDisconnected();
 
       var participants = store.getStoreState().participants;
       expect(participants).to.have.length.of(1);
       expect(participants[0].owner).eql(true);
     });
@@ -1794,17 +1794,17 @@ describe("loop.store.ActiveRoomStore", f
 
       sinon.assert.calledOnce(fakeMozLoop.rooms.leave);
       sinon.assert.calledWithExactly(fakeMozLoop.rooms.leave,
         "fakeToken", "1627384950");
     });
 
     it("should call mozLoop.rooms.leave if the room state is JOINING",
       function() {
-        store.setStoreState({roomState: ROOM_STATES.JOINING});
+        store.setStoreState({ roomState: ROOM_STATES.JOINING });
 
         store.windowUnload();
 
         sinon.assert.calledOnce(fakeMozLoop.rooms.leave);
         sinon.assert.calledWithExactly(fakeMozLoop.rooms.leave,
           "fakeToken", "1627384950");
       });
 
--- a/browser/components/loop/test/shared/crypto_test.js
+++ b/browser/components/loop/test/shared/crypto_test.js
@@ -50,34 +50,34 @@ describe("loop.crypto", function() {
 
       expect(function() {
         loop.crypto.encryptBytes();
       }).to.Throw(/not supported/);
     });
 
     it("should encrypt an object with a specific key", function() {
       return expect(loop.crypto.encryptBytes("Wt2-bZKeHO2wnaq00ZM6Nw",
-        JSON.stringify({test: true}))).to.eventually.be.a("string");
+        JSON.stringify({ test: true }))).to.eventually.be.a("string");
     });
   });
 
   describe("#decryptBytes", function() {
     it("should throw if web crypto is not available", function() {
       loop.crypto.setRootObject({});
 
       expect(function() {
         loop.crypto.decryptBytes();
       }).to.Throw(/not supported/);
     });
 
     it("should decypt an object via a specific key", function() {
       var key = "Wt2-bZKeHO2wnaq00ZM6Nw";
       var encryptedContext = "XvN9FDEm/GtE/5Bx5ezpn7JVDeZrtwOJy2CBjTGgJ4L33HhHOqEW+5k=";
 
-      return expect(loop.crypto.decryptBytes(key, encryptedContext)).to.eventually.eql(JSON.stringify({test: true}));
+      return expect(loop.crypto.decryptBytes(key, encryptedContext)).to.eventually.eql(JSON.stringify({ test: true }));
     });
 
     it("should fail if the key didn't work", function() {
       var bad = "Bad-bZKeHO2wnaq00ZM6Nw";
       var encryptedContext = "TGZaAE3mqsBFK0GfheZXXDCaRKXJmIKJ8WzF0KBEl4Aldzf3iYlAsLQdA8XSXXvtJR2UYz+f";
 
       return expect(loop.crypto.decryptBytes(bad, encryptedContext)).to.be.rejected;
     });
--- a/browser/components/loop/test/shared/linkifiedTextView_test.js
+++ b/browser/components/loop/test/shared/linkifiedTextView_test.js
@@ -35,42 +35,42 @@ describe("loop.shared.views.LinkifiedTex
   var LinkifiedTextView = loop.shared.views.LinkifiedTextView;
   var TestUtils = React.addons.TestUtils;
 
   describe("LinkifiedTextView", function () {
     function renderToMarkup(string, extraProps) {
       return React.renderToStaticMarkup(
         React.createElement(
           LinkifiedTextView,
-          _.extend({rawText: string}, extraProps)));
+          _.extend({ rawText: string }, extraProps)));
     }
 
     describe("#render", function() {
       function testRender(testData) {
         it(testData.desc, function() {
           var markup = renderToMarkup(testData.rawText,
-            {suppressTarget: true, sendReferrer: true});
+            { suppressTarget: true, sendReferrer: true });
 
           expect(markup).to.equal(testData.markup);
         });
       }
 
       function testSkip(testData) {
         it.skip(testData.desc, function() {
           var markup = renderToMarkup(testData.rawText,
-            {suppressTarget: true, sendReferrer: true});
+            { suppressTarget: true, sendReferrer: true });
 
           expect(markup).to.equal(testData.markup);
         });
       }
 
       describe("this.props.suppressTarget", function() {
         it("should make links w/o a target attr if suppressTarget is true",
           function() {
-            var markup = renderToMarkup("http://example.com", {suppressTarget: true});
+            var markup = renderToMarkup("http://example.com", { suppressTarget: true });
 
             expect(markup).to.equal(
               '<p><a href="http://example.com" rel="noreferrer">http://example.com</a></p>');
           });
 
         it("should make links with target=_blank if suppressTarget is not given",
           function() {
             var markup = renderToMarkup("http://example.com", {});
@@ -78,17 +78,17 @@ describe("loop.shared.views.LinkifiedTex
             expect(markup).to.equal(
               '<p><a href="http://example.com" target="_blank" rel="noreferrer">http://example.com</a></p>');
           });
       });
 
       describe("this.props.sendReferrer", function() {
         it("should make links w/o rel=noreferrer if sendReferrer is true",
           function() {
-            var markup = renderToMarkup("http://example.com", {sendReferrer: true});
+            var markup = renderToMarkup("http://example.com", { sendReferrer: true });
 
             expect(markup).to.equal(
               '<p><a href="http://example.com" target="_blank">http://example.com</a></p>');
           });
 
         it("should make links with rel=noreferrer if sendReferrer is not given",
           function() {
             var markup = renderToMarkup("http://example.com", {});
@@ -98,23 +98,23 @@ describe("loop.shared.views.LinkifiedTex
           });
       });
 
       describe("this.props.linkClickHandler", function () {
         function mountTestComponent(string, extraProps) {
           return TestUtils.renderIntoDocument(
             React.createElement(
               LinkifiedTextView,
-              _.extend({rawText: string}, extraProps)));
+              _.extend({ rawText: string }, extraProps)));
         }
 
         it("should be called when a generated link is clicked", function () {
           var fakeUrl = "http://example.com";
           var linkClickHandler = sinon.stub();
-          var comp = mountTestComponent(fakeUrl, {linkClickHandler: linkClickHandler});
+          var comp = mountTestComponent(fakeUrl, { linkClickHandler: linkClickHandler });
 
           TestUtils.Simulate.click(comp.getDOMNode().querySelector("a"));
 
           sinon.assert.calledOnce(linkClickHandler);
         });
 
         it("should cause sendReferrer and suppressTarget props to be ignored",
           function() {
@@ -141,39 +141,39 @@ describe("loop.shared.views.LinkifiedTex
               preventDefault: sinon.stub(),
               stopPropagation: sinon.stub()
             };
           });
 
           it("should call preventDefault on the given event", function () {
             function linkClickHandler() {}
             var comp = mountTestComponent(
-              fakeUrl, {linkClickHandler: linkClickHandler});
+              fakeUrl, { linkClickHandler: linkClickHandler });
 
             comp._handleClickEvent(fakeEvent);
 
             sinon.assert.calledOnce(fakeEvent.preventDefault);
             sinon.assert.calledWithExactly(fakeEvent.stopPropagation);
           });
 
           it("should call stopPropagation on the given event", function () {
             function linkClickHandler() {}
             var comp = mountTestComponent(
-              fakeUrl, {linkClickHandler: linkClickHandler});
+              fakeUrl, { linkClickHandler: linkClickHandler });
 
             comp._handleClickEvent(fakeEvent);
 
             sinon.assert.calledOnce(fakeEvent.stopPropagation);
             sinon.assert.calledWithExactly(fakeEvent.stopPropagation);
           });
 
           it("should call this.props.linkClickHandler with event.currentTarget.href", function () {
             var linkClickHandler = sinon.stub();
             var comp = mountTestComponent(
-              fakeUrl, {linkClickHandler: linkClickHandler});
+              fakeUrl, { linkClickHandler: linkClickHandler });
 
             comp._handleClickEvent(fakeEvent);
 
             sinon.assert.calledOnce(linkClickHandler);
             sinon.assert.calledWithExactly(linkClickHandler, fakeUrl);
           });
         });
       });
--- a/browser/components/loop/test/shared/mixins_test.js
+++ b/browser/components/loop/test/shared/mixins_test.js
@@ -168,27 +168,27 @@ describe("loop.shared.mixins", function(
           },
           removeEventListener: sandbox.stub()
         }
       });
     }
 
     it("should call onDocumentVisible when document visibility changes to visible",
       function() {
-        setupFakeVisibilityEventDispatcher({target: {hidden: false}});
+        setupFakeVisibilityEventDispatcher({ target: { hidden: false } });
 
         comp = TestUtils.renderIntoDocument(React.createElement(TestComp));
 
         // Twice, because it's also called when the component was mounted.
         sinon.assert.calledTwice(onDocumentVisibleStub);
       });
 
     it("should call onDocumentVisible when document visibility changes to hidden",
       function() {
-        setupFakeVisibilityEventDispatcher({target: {hidden: true}});
+        setupFakeVisibilityEventDispatcher({ target: { hidden: true } });
 
         comp = TestUtils.renderIntoDocument(React.createElement(TestComp));
 
         sinon.assert.calledOnce(onDocumentHiddenStub);
       });
   });
 
   describe("loop.shared.mixins.MediaSetupMixin", function() {
@@ -222,17 +222,17 @@ describe("loop.shared.mixins", function(
 
   describe("loop.shared.mixins.AudioMixin", function() {
     var view, fakeAudio, TestComp;
 
     beforeEach(function() {
       navigator.mozLoop = {
         doNotDisturb: true,
         getAudioBlob: sinon.spy(function(name, callback) {
-          callback(null, new Blob([new ArrayBuffer(10)], {type: "audio/ogg"}));
+          callback(null, new Blob([new ArrayBuffer(10)], { type: "audio/ogg" }));
         }),
         getLoopPref: sandbox.stub()
       };
 
       fakeAudio = {
         play: sinon.spy(),
         pause: sinon.spy(),
         removeAttribute: sinon.spy()
@@ -274,76 +274,76 @@ describe("loop.shared.mixins", function(
     function createTestComponent(initialState) {
       var TestComp = React.createClass({
         mixins: [loop.shared.mixins.RoomsAudioMixin],
         render: function() {
           return React.DOM.div();
         },
 
         getInitialState: function() {
-          return { roomState: initialState};
+          return { roomState: initialState };
         }
       });
 
       var renderedComp = TestUtils.renderIntoDocument(
         React.createElement(TestComp));
       sandbox.stub(renderedComp, "play");
       return renderedComp;
     }
 
     beforeEach(function() {
     });
 
     it("should play a sound when the local user joins the room", function() {
       comp = createTestComponent(ROOM_STATES.INIT);
 
-      comp.setState({roomState: ROOM_STATES.SESSION_CONNECTED});
+      comp.setState({ roomState: ROOM_STATES.SESSION_CONNECTED });
 
       sinon.assert.calledOnce(comp.play);
       sinon.assert.calledWithExactly(comp.play, "room-joined");
     });
 
     it("should play a sound when another user joins the room", function() {
       comp = createTestComponent(ROOM_STATES.SESSION_CONNECTED);
 
-      comp.setState({roomState: ROOM_STATES.HAS_PARTICIPANTS});
+      comp.setState({ roomState: ROOM_STATES.HAS_PARTICIPANTS });
 
       sinon.assert.calledOnce(comp.play);
       sinon.assert.calledWithExactly(comp.play, "room-joined-in");
     });
 
     it("should play a sound when another user leaves the room", function() {
       comp = createTestComponent(ROOM_STATES.HAS_PARTICIPANTS);
 
-      comp.setState({roomState: ROOM_STATES.SESSION_CONNECTED});
+      comp.setState({ roomState: ROOM_STATES.SESSION_CONNECTED });
 
       sinon.assert.calledOnce(comp.play);
       sinon.assert.calledWithExactly(comp.play, "room-left");
     });
 
     it("should play a sound when the local user leaves the room", function() {
       comp = createTestComponent(ROOM_STATES.HAS_PARTICIPANTS);
 
-      comp.setState({roomState: ROOM_STATES.READY});
+      comp.setState({ roomState: ROOM_STATES.READY });
 
       sinon.assert.calledOnce(comp.play);
       sinon.assert.calledWithExactly(comp.play, "room-left");
     });
 
     it("should play a sound when if there is a failure", function() {
       comp = createTestComponent(ROOM_STATES.HAS_PARTICIPANTS);
 
-      comp.setState({roomState: ROOM_STATES.FAILED});
+      comp.setState({ roomState: ROOM_STATES.FAILED });
 
       sinon.assert.calledOnce(comp.play);
       sinon.assert.calledWithExactly(comp.play, "failure");
     });
 
     it("should play a sound when if the room is full", function() {
       comp = createTestComponent(ROOM_STATES.READY);
 
-      comp.setState({roomState: ROOM_STATES.FULL});
+      comp.setState({ roomState: ROOM_STATES.FULL });
 
       sinon.assert.calledOnce(comp.play);
       sinon.assert.calledWithExactly(comp.play, "failure");
     });
   });
 });
--- a/browser/components/loop/test/shared/models_test.js
+++ b/browser/components/loop/test/shared/models_test.js
@@ -21,17 +21,17 @@ describe("loop.shared.models", function(
   describe("NotificationCollection", function() {
     var collection, notifData, testNotif;
 
     beforeEach(function() {
       collection = new sharedModels.NotificationCollection();
       sandbox.stub(l10n, "get", function(x, y) {
         return "translated:" + x + (y ? ":" + y : "");
       });
-      notifData = {level: "error", message: "plop"};
+      notifData = { level: "error", message: "plop" };
       testNotif = new sharedModels.NotificationModel(notifData);
     });
 
     describe("#warn", function() {
       it("should add a warning notification to the stack", function() {
         collection.warn("watch out");
 
         expect(collection).to.have.length.of(1);
--- a/browser/components/loop/test/shared/otSdkDriver_test.js
+++ b/browser/components/loop/test/shared/otSdkDriver_test.js
@@ -105,17 +105,17 @@ describe("loop.OTSdkDriver", function ()
     it("should throw an error if the dispatcher is missing", function() {
       expect(function() {
         new loop.OTSdkDriver({ sdk: sdk });
       }).to.Throw(/dispatcher/);
     });
 
     it("should throw an error if the sdk is missing", function() {
       expect(function() {
-        new loop.OTSdkDriver({dispatcher: dispatcher});
+        new loop.OTSdkDriver({ dispatcher: dispatcher });
       }).to.Throw(/sdk/);
     });
 
     it("should set the metrics to zero", function() {
       driver = new loop.OTSdkDriver({
         dispatcher: dispatcher,
         sdk: sdk
       });
@@ -345,17 +345,17 @@ describe("loop.OTSdkDriver", function ()
 
       sinon.assert.calledOnce(session.connect);
       sinon.assert.calledWith(session.connect, "1234567890", "1357924680");
     });
 
     it("should set the two-way media start time to 'uninitialized' " +
        "when sessionData.sendTwoWayMediaTelemetry is true'", function() {
       driver.connectSession(_.extend(sessionData,
-                                     {sendTwoWayMediaTelemetry: true}));
+                                     { sendTwoWayMediaTelemetry: true }));
 
       expect(driver._getTwoWayMediaStartTime()).to.eql(
         driver.CONNECTION_START_TIME_UNINITIALIZED);
     });
 
     describe("On connection complete", function() {
       beforeEach(function() {
         sandbox.stub(window.console, "error");
@@ -697,26 +697,26 @@ describe("loop.OTSdkDriver", function ()
       driver._sessionConnected = true;
 
       // Setup the right state in the driver to make `forceDisconnectAll` do
       // something.
       session.connection = {
         id: "localUser"
       };
       session.trigger("connectionCreated", {
-        connection: {id: "remoteUser"}
+        connection: { id: "remoteUser" }
       });
       expect(driver.connections).to.include.keys("remoteUser");
 
       driver.forceDisconnectAll(function() {});
       sinon.assert.calledOnce(session.forceDisconnect);
 
       // Add another remote connection.
       session.trigger("connectionCreated", {
-        connection: {id: "remoteUser2"}
+        connection: { id: "remoteUser2" }
       });
       expect(driver.connections).to.include.keys("remoteUser", "remoteUser2");
 
       driver.forceDisconnectAll(function() {});
       sinon.assert.calledThrice(session.forceDisconnect);
     });
 
     describe("#sendTextChatMessage", function() {
@@ -743,17 +743,17 @@ describe("loop.OTSdkDriver", function ()
     var fakeConnection, fakeStream, fakeSubscriberObject,
       fakeSdkContainerWithVideo, videoElement;
 
     beforeEach(function() {
       fakeConnection = "fakeConnection";
       fakeStream = {
         hasVideo: true,
         videoType: "camera",
-        videoDimensions: {width: 1, height: 2}
+        videoDimensions: { width: 1, height: 2 }
       };
 
       fakeSubscriberObject = _.extend({
         session: { connection: fakeConnection },
         stream: fakeStream
       }, Backbone.Events);
 
       fakeSdkContainerWithVideo = {
@@ -902,29 +902,29 @@ describe("loop.OTSdkDriver", function ()
       beforeEach(function() {
         driver._mockPublisherEl = document.createElement("div");
         fakeMockVideo = document.createElement("video");
 
         driver._mockPublisherEl.appendChild(fakeMockVideo);
         stream = {
           hasVideo: true,
           videoType: "camera",
-          videoDimensions: {width: 1, height: 2}
+          videoDimensions: { width: 1, height: 2 }
         };
       });
 
       it("should dispatch a VideoDimensionsChanged action", function() {
         publisher.trigger("streamCreated", { stream: stream });
 
         sinon.assert.called(dispatcher.dispatch);
         sinon.assert.calledWithExactly(dispatcher.dispatch,
           new sharedActions.VideoDimensionsChanged({
             isLocal: true,
             videoType: "camera",
-            dimensions: {width: 1, height: 2}
+            dimensions: { width: 1, height: 2 }
           }));
       });
 
       it("should dispatch a MediaStreamCreated action", function() {
         publisher.trigger("streamCreated", { stream: stream });
 
         sinon.assert.called(dispatcher.dispatch);
         sinon.assert.calledWithExactly(dispatcher.dispatch,
@@ -947,17 +947,17 @@ describe("loop.OTSdkDriver", function ()
             srcMediaElement: fakeMockVideo
           }));
       });
 
       it("should dispatch a ConnectionStatus action", function() {
         driver._metrics.recvStreams = 1;
         driver._metrics.connections = 2;
 
-        publisher.trigger("streamCreated", {stream: stream});
+        publisher.trigger("streamCreated", { stream: stream });
 
         sinon.assert.called(dispatcher.dispatch);
         sinon.assert.calledWithExactly(dispatcher.dispatch,
           new sharedActions.ConnectionStatus({
             event: "Publisher.streamCreated",
             state: "sendrecv",
             connections: 2,
             recvStreams: 1,
@@ -1127,20 +1127,20 @@ describe("loop.OTSdkDriver", function ()
           session.trigger("streamCreated", { stream: fakeStream });
 
           sinon.assert.neverCalledWithMatch(dispatcher.dispatch,
             sinon.match.hasOwn("name", "mediaConnected"));
         });
 
       it("should not dispatch a ReceivingScreenShare action for camera streams",
         function() {
-          session.trigger("streamCreated", {stream: fakeStream});
+          session.trigger("streamCreated", { stream: fakeStream });
 
           sinon.assert.neverCalledWithMatch(dispatcher.dispatch,
-            new sharedActions.ReceivingScreenShare({receiving: true}));
+            new sharedActions.ReceivingScreenShare({ receiving: true }));
         });
 
       it("should dispatch a ReceivingScreenShare action for screen" +
         " sharing streams", function() {
           fakeStream.videoType = "screen";
 
           session.trigger("streamCreated", { stream: fakeStream });
 
@@ -1210,17 +1210,17 @@ describe("loop.OTSdkDriver", function ()
           }));
       });
 
       it("should dispatch a ConnectionStatus action", function() {
         driver._metrics.connections = 2;
         driver._metrics.sendStreams = 1;
         driver._metrics.recvStreams = 1;
 
-        session.trigger("streamDestroyed", {stream: stream});
+        session.trigger("streamDestroyed", { stream: stream });
 
         sinon.assert.called(dispatcher.dispatch);
         sinon.assert.calledWithExactly(dispatcher.dispatch,
           new sharedActions.ConnectionStatus({
             event: "Session.streamDestroyed",
             state: "sending",
             connections: 2,
             recvStreams: 0,
@@ -1443,34 +1443,34 @@ describe("loop.OTSdkDriver", function ()
         sinon.assert.calledOnce(fakeEvent.preventDefault);
       });
     });
 
     describe("videoEnabled", function() {
       it("should dispatch a RemoteVideoStatus action", function() {
         session.subscribe.yieldsOn(driver, null, fakeSubscriberObject,
           videoElement).returns(this.fakeSubscriberObject);
-        session.trigger("streamCreated", {stream: fakeSubscriberObject.stream});
+        session.trigger("streamCreated", { stream: fakeSubscriberObject.stream });
         driver._mockSubscribeEl.appendChild(videoElement);
 
         fakeSubscriberObject.trigger("videoEnabled");
 
         sinon.assert.called(dispatcher.dispatch);
         sinon.assert.calledWith(dispatcher.dispatch,
           new sharedActions.RemoteVideoStatus({
             videoEnabled: true
           }));
       });
     });
 
     describe("videoDisabled", function() {
       it("should dispatch a RemoteVideoStatus action", function() {
         session.subscribe.yieldsOn(driver, null, fakeSubscriberObject,
           videoElement).returns(this.fakeSubscriberObject);
-        session.trigger("streamCreated", {stream: fakeSubscriberObject.stream});
+        session.trigger("streamCreated", { stream: fakeSubscriberObject.stream });
 
 
         fakeSubscriberObject.trigger("videoDisabled");
 
         sinon.assert.called(dispatcher.dispatch);
         sinon.assert.calledWithExactly(dispatcher.dispatch,
           new sharedActions.RemoteVideoStatus({
             videoEnabled: false
--- a/browser/components/loop/test/shared/store_test.js
+++ b/browser/components/loop/test/shared/store_test.js
@@ -35,18 +35,18 @@ describe("loop.store", function () {
           var TestStore = loop.store.createStore({});
           expect(function() {
             new TestStore();
           }).to.Throw(/required dispatcher/);
         });
 
         it("should call initialize() when constructed, if defined", function() {
           var initialize = sandbox.spy();
-          var TestStore = loop.store.createStore({initialize: initialize});
-          var options = {fake: true};
+          var TestStore = loop.store.createStore({ initialize: initialize });
+          var options = { fake: true };
 
           new TestStore(dispatcher, options);
 
           sinon.assert.calledOnce(initialize);
           sinon.assert.calledWithExactly(initialize, options);
         });
 
         it("should register actions", function() {
@@ -74,23 +74,23 @@ describe("loop.store", function () {
           }).to.Throw(/should implement an action handler for b/);
         });
       });
 
       describe("#getInitialStoreState", function() {
         it("should set initial store state if provided", function() {
           var TestStore = loop.store.createStore({
             getInitialStoreState: function() {
-              return {foo: "bar"};
+              return { foo: "bar" };
             }
           });
 
           var store = new TestStore(dispatcher);
 
-          expect(store.getStoreState()).eql({foo: "bar"});
+          expect(store.getStoreState()).eql({ foo: "bar" });
         });
       });
 
       describe("#dispatchAction", function() {
         it("should dispatch an action", function() {
           sandbox.stub(dispatcher, "dispatch");
           var TestStore = loop.store.createStore({});
           var TestAction = sharedActions.Action.define("TestAction", {});
@@ -105,101 +105,101 @@ describe("loop.store", function () {
       });
 
       describe("#getStoreState", function() {
         var TestStore = loop.store.createStore({});
         var store;
 
         beforeEach(function() {
           store = new TestStore(dispatcher);
-          store.setStoreState({foo: "bar", bar: "baz"});
+          store.setStoreState({ foo: "bar", bar: "baz" });
         });
 
         it("should retrieve the whole state by default", function() {
-          expect(store.getStoreState()).eql({foo: "bar", bar: "baz"});
+          expect(store.getStoreState()).eql({ foo: "bar", bar: "baz" });
         });
 
         it("should retrieve a given property state", function() {
           expect(store.getStoreState("bar")).eql("baz");
         });
       });
 
       describe("#setStoreState", function() {
         var TestStore = loop.store.createStore({});
         var store;
 
         beforeEach(function() {
           store = new TestStore(dispatcher);
-          store.setStoreState({foo: "bar"});
+          store.setStoreState({ foo: "bar" });
         });
 
         it("should update store state data", function() {
-          store.setStoreState({foo: "baz"});
+          store.setStoreState({ foo: "baz" });
 
           expect(store.getStoreState("foo")).eql("baz");
         });
 
         it("should trigger a `change` event", function(done) {
           store.once("change", function() {
             done();
           });
 
-          store.setStoreState({foo: "baz"});
+          store.setStoreState({ foo: "baz" });
         });
 
         it("should trigger a `change:<prop>` event", function(done) {
           store.once("change:foo", function() {
             done();
           });
 
-          store.setStoreState({foo: "baz"});
+          store.setStoreState({ foo: "baz" });
         });
       });
     });
   });
 
   describe("loop.store.StoreMixin", function() {
     var view1, view2, store, storeClass, testComp;
 
     beforeEach(function() {
       storeClass = loop.store.createStore({});
 
       store = new storeClass(dispatcher);
 
-      loop.store.StoreMixin.register({store: store});
+      loop.store.StoreMixin.register({ store: store });
 
       testComp = React.createClass({
         mixins: [loop.store.StoreMixin("store")],
         render: function() {
           return React.DOM.div();
         }
       });
 
       view1 = TestUtils.renderIntoDocument(React.createElement(testComp));
     });
 
     it("should update the state when the store changes", function() {
-      store.setStoreState({test: true});
+      store.setStoreState({ test: true });
 
-      expect(view1.state).eql({test: true});
+      expect(view1.state).eql({ test: true });
     });
 
     it("should stop listening to state changes", function() {
       // There's no easy way in TestUtils to unmount, so simulate it.
       view1.componentWillUnmount();
 
-      store.setStoreState({test2: true});
+      store.setStoreState({ test2: true });
 
       expect(view1.state).eql(null);
     });
 
     it("should not stop listening to state changes on other components", function() {
       view2 = TestUtils.renderIntoDocument(React.createElement(testComp));
 
       // There's no easy way in TestUtils to unmount, so simulate it.
       view1.componentWillUnmount();
 
-      store.setStoreState({test3: true});
+      store.setStoreState({ test3: true });
 
-      expect(view2.state).eql({test3: true});
+      expect(view2.state).eql({ test3: true });
     });
   });
 });
--- a/browser/components/loop/test/shared/utils_test.js
+++ b/browser/components/loop/test/shared/utils_test.js
@@ -60,17 +60,17 @@ describe("loop.shared.utils", function()
     });
 
     it("should call toLocaleDateString with arguments", function() {
       sharedUtils.formatDate(1000);
 
       sinon.assert.calledOnce(Date.prototype.toLocaleDateString);
       sinon.assert.calledWithExactly(Date.prototype.toLocaleDateString,
         navigator.language,
-        {year: "numeric", month: "long", day: "numeric"}
+        { year: "numeric", month: "long", day: "numeric" }
       );
     });
 
     it("should return the formatted string", function() {
       expect(sharedUtils.formatDate(1000)).eql("fake result");
     });
   });
 
--- a/browser/components/loop/test/shared/validate_test.js
+++ b/browser/components/loop/test/shared/validate_test.js
@@ -21,67 +21,67 @@ describe("Validator", function() {
     var rtcsd;
 
     beforeEach(function() {
       rtcsd = new RTCSessionDescription();
     });
 
     it("should check for a single required dependency when no option passed",
       function() {
-        expect(create({x: Number}, {}))
+        expect(create({ x: Number }, {}))
           .to.Throw(TypeError, /missing required x$/);
       });
 
     it("should check for a missing required dependency, undefined passed",
       function() {
-        expect(create({x: Number}, {x: undefined}))
+        expect(create({ x: Number }, { x: undefined }))
           .to.Throw(TypeError, /missing required x$/);
       });
 
     it("should check for multiple missing required dependencies", function() {
-      expect(create({x: Number, y: String}, {}))
+      expect(create({ x: Number, y: String }, {}))
         .to.Throw(TypeError, /missing required x, y$/);
     });
 
     it("should check for required dependency types", function() {
-      expect(create({x: Number}, {x: "woops"})).to.Throw(
+      expect(create({ x: Number }, { x: "woops" })).to.Throw(
         TypeError, /invalid dependency: x; expected Number, got String$/);
     });
 
     it("should check for a dependency to match at least one of passed types",
       function() {
-        expect(create({x: [X, Y]}, {x: 42})).to.Throw(
+        expect(create({ x: [X, Y] }, { x: 42 })).to.Throw(
           TypeError, /invalid dependency: x; expected X, Y, got Number$/);
-        expect(create({x: [X, Y]}, {x: new Y()})).to.not.Throw();
+        expect(create({ x: [X, Y] }, { x: new Y() })).to.not.Throw();
       });
 
     it("should skip type check if required dependency type is undefined",
       function() {
-        expect(create({x: undefined}, {x: /whatever/})).not.to.Throw();
+        expect(create({ x: undefined }, { x: /whatever/ })).not.to.Throw();
       });
 
     it("should check for a String dependency", function() {
-      expect(create({foo: String}, {foo: 42})).to.Throw(
+      expect(create({ foo: String }, { foo: 42 })).to.Throw(
         TypeError, /invalid dependency: foo/);
     });
 
     it("should check for a Number dependency", function() {
-      expect(create({foo: Number}, {foo: "x"})).to.Throw(
+      expect(create({ foo: Number }, { foo: "x" })).to.Throw(
         TypeError, /invalid dependency: foo/);
     });
 
     it("should check for a custom constructor dependency", function() {
-      expect(create({foo: X}, {foo: null})).to.Throw(
+      expect(create({ foo: X }, { foo: null })).to.Throw(
         TypeError, /invalid dependency: foo; expected X, got null$/);
     });
 
     it("should check for a native constructor dependency", function() {
-      expect(create({foo: rtcsd}, {foo: "x"}))
+      expect(create({ foo: rtcsd }, { foo: "x" }))
         .to.Throw(TypeError,
                   /invalid dependency: foo; expected RTCSessionDescription/);
     });
 
     it("should check for a null dependency", function() {
-      expect(create({foo: null}, {foo: "x"})).to.Throw(
+      expect(create({ foo: null }, { foo: "x" })).to.Throw(
         TypeError, /invalid dependency: foo; expected null, got String$/);
     });
   });
 });
--- a/browser/components/loop/test/shared/views_test.js
+++ b/browser/components/loop/test/shared/views_test.js
@@ -309,49 +309,49 @@ describe("loop.shared.views", function()
       }, props);
 
       return TestUtils.renderIntoDocument(
         React.createElement(sharedViews.SettingsControlButton, props));
     }
 
     it("should render a visible button", function() {
       var settingsMenuItems = [{ id: "help" }];
-      var comp = mountTestComponent({ menuItems: settingsMenuItems} );
+      var comp = mountTestComponent({ menuItems: settingsMenuItems } );
 
       var node = comp.getDOMNode().querySelector(".btn-settings");
       expect(node.classList.contains("hide")).eql(false);
     });
 
     it("should not render anything", function() {
       var comp = mountTestComponent();
       expect(comp.getDOMNode()).to.eql(null);
     });
 
     it("should not show an indefined menu option", function() {
       var settingsMenuItems = [
         { id: "not Defined" },
         { id: "help" }
       ];
-      var comp = mountTestComponent({ menuItems: settingsMenuItems} );
+      var comp = mountTestComponent({ menuItems: settingsMenuItems } );
       var menuItems = comp.getDOMNode().querySelectorAll(".settings-menu > li");
       expect(menuItems).to.have.length.of(1);
     });
 
     it("should not render anythin if not exists any valid item to show", function() {
       var settingsMenuItems = [
         { id: "not Defined" },
         { id: "another wrong menu item" }
       ];
-      var comp = mountTestComponent({ menuItems: settingsMenuItems} );
+      var comp = mountTestComponent({ menuItems: settingsMenuItems } );
       expect(comp.getDOMNode()).to.eql(null);
     });
 
     it("should show the settings dropdown on click", function() {
       var settingsMenuItems = [{ id: "help" }];
-      var comp = mountTestComponent({ menuItems: settingsMenuItems} );
+      var comp = mountTestComponent({ menuItems: settingsMenuItems } );
 
       expect(comp.state.showMenu).eql(false);
       TestUtils.Simulate.click(comp.getDOMNode().querySelector(".btn-settings"));
 
       expect(comp.state.showMenu).eql(true);
     });
 
     it("should have a `menu-below` class on the dropdown when the prop is set.", function() {
@@ -383,58 +383,58 @@ describe("loop.shared.views", function()
       var settingsMenuItems = [
         {
           id: "edit",
           enabled: true,
           visible: true,
           onClick: function() {}
         }
       ];
-      var comp = mountTestComponent({ menuItems: settingsMenuItems} );
+      var comp = mountTestComponent({ menuItems: settingsMenuItems } );
 
       var node = comp.getDOMNode().querySelector(".settings-menu > li.entry-settings-edit");
       expect(node.classList.contains("hide")).eql(false);
     });
 
     it("should hide edit Context on menu when the option is not visible", function() {
       var settingsMenuItems = [
         {
           id: "edit",
           enabled: false,
           visible: false,
           onClick: function() {}
         }
       ];
-      var comp = mountTestComponent({ menuItems: settingsMenuItems} );
+      var comp = mountTestComponent({ menuItems: settingsMenuItems } );
 
       var node = comp.getDOMNode().querySelector(".settings-menu > li.entry-settings-edit");
       expect(node.classList.contains("hide")).eql(true);
     });
 
     it("should call onClick method when the edit context menu item is clicked", function() {
       var onClickCalled = false;
       var settingsMenuItems = [
         {
           id: "edit",
           enabled: true,
           visible: true,
           onClick: sandbox.stub()
         }
       ];
-      var comp = mountTestComponent({ menuItems: settingsMenuItems} );
+      var comp = mountTestComponent({ menuItems: settingsMenuItems } );
 
       TestUtils.Simulate.click(comp.getDOMNode().querySelector(".settings-menu > li.entry-settings-edit"));
       sinon.assert.calledOnce(settingsMenuItems[0].onClick);
     });
 
     it("should open a tab to the support url when the support menu item is clicked", function() {
       var settingsMenuItems = [
         { id: "help" }
       ];
-      var comp = mountTestComponent({ menuItems: settingsMenuItems} );
+      var comp = mountTestComponent({ menuItems: settingsMenuItems } );
 
       TestUtils.Simulate.click(comp.getDOMNode().querySelector(".settings-menu > li:last-child"));
 
       sinon.assert.calledOnce(fakeMozLoop.openURL);
       sinon.assert.calledWithExactly(fakeMozLoop.openURL, support_url);
     });
   });
 
@@ -516,73 +516,73 @@ describe("loop.shared.views", function()
 
       expect(comp.getDOMNode().querySelector(".btn-hangup-entry")).to.eql(null);
     });
 
     it("should hangup when hangup button is clicked", function() {
       var comp = mountTestComponent({
         hangup: hangup,
         publishStream: publishStream,
-        audio: {enabled: true}
+        audio: { enabled: true }
       });
 
       TestUtils.Simulate.click(
         comp.getDOMNode().querySelector(".btn-hangup"));
 
       sinon.assert.calledOnce(hangup);
       sinon.assert.calledWithExactly(hangup);
     });
 
     it("should unpublish audio when audio mute btn is clicked", function() {
       var comp = mountTestComponent({
         hangup: hangup,
         publishStream: publishStream,
-        audio: {enabled: true}
+        audio: { enabled: true }
       });
 
       TestUtils.Simulate.click(
         comp.getDOMNode().querySelector(".btn-mute-audio"));
 
       sinon.assert.calledOnce(publishStream);
       sinon.assert.calledWithExactly(publishStream, "audio", false);
     });
 
     it("should publish audio when audio mute btn is clicked", function() {
       var comp = mountTestComponent({
         hangup: hangup,
         publishStream: publishStream,
-        audio: {enabled: false}
+        audio: { enabled: false }
       });
 
       TestUtils.Simulate.click(
         comp.getDOMNode().querySelector(".btn-mute-audio"));
 
       sinon.assert.calledOnce(publishStream);
       sinon.assert.calledWithExactly(publishStream, "audio", true);
     });
 
     it("should unpublish video when video mute btn is clicked", function() {
       var comp = mountTestComponent({
         hangup: hangup,
         publishStream: publishStream,
-        video: {enabled: true}
+        video: { enabled: true }
       });
 
       TestUtils.Simulate.click(
         comp.getDOMNode().querySelector(".btn-mute-video"));
 
       sinon.assert.calledOnce(publishStream);
       sinon.assert.calledWithExactly(publishStream, "video", false);
     });
 
     it("should publish video when video mute btn is clicked", function() {
       var comp = mountTestComponent({
         hangup: hangup,
         publishStream: publishStream,
-        video: {enabled: false}
+        video: { enabled: false }
       });
 
       TestUtils.Simulate.click(
         comp.getDOMNode().querySelector(".btn-mute-video"));
 
       sinon.assert.calledOnce(publishStream);
       sinon.assert.calledWithExactly(publishStream, "video", true);
     });
@@ -596,18 +596,18 @@ describe("loop.shared.views", function()
         key: 0
       }, props || {});
       return TestUtils.renderIntoDocument(
         React.createElement(sharedViews.NotificationListView, props));
     }
 
     beforeEach(function() {
       coll = new sharedModels.NotificationCollection();
-      view = mountTestComponent({notifications: coll});
-      testNotif = {level: "warning", message: "foo"};
+      view = mountTestComponent({ notifications: coll });
+      testNotif = { level: "warning", message: "foo" };
       sinon.spy(view, "render");
     });
 
     afterEach(function() {
       view.render.restore();
     });
 
     describe("Collection events", function() {
@@ -685,17 +685,17 @@ describe("loop.shared.views", function()
         expect(checkbox.classList.contains("checked")).eql(true);
       });
 
       it("should alter the render state when the props are changed", function() {
         view = mountTestComponent({
           checked: true
         });
 
-        view.setProps({checked: false});
+        view.setProps({ checked: false });
 
         var checkbox = view.getDOMNode().querySelector(".checkbox");
         expect(checkbox.classList.contains("checked")).eql(false);
       });
 
       it("should add an ellipsis class when the prop is set", function() {
         view = mountTestComponent({
           label: "Some label",
@@ -974,44 +974,44 @@ describe("loop.shared.views", function()
       });
 
       it("should attach a video object according to the standard", function() {
         fakeViewElement.srcObject = null;
 
         sinon.stub(view, "getDOMNode").returns(fakeViewElement);
 
         view.attachVideo({
-          srcObject: {fake: 1}
+          srcObject: { fake: 1 }
         });
 
-        expect(fakeViewElement.srcObject).eql({fake: 1});
+        expect(fakeViewElement.srcObject).eql({ fake: 1 });
       });
 
       it("should attach a video object for Firefox", function() {
         fakeViewElement.mozSrcObject = null;
 
         sinon.stub(view, "getDOMNode").returns(fakeViewElement);
 
         view.attachVideo({
-          mozSrcObject: {fake: 2}
+          mozSrcObject: { fake: 2 }
         });
 
-        expect(fakeViewElement.mozSrcObject).eql({fake: 2});
+        expect(fakeViewElement.mozSrcObject).eql({ fake: 2 });
       });
 
       it("should attach a video object for Chrome", function() {
         fakeViewElement.src = null;
 
         sinon.stub(view, "getDOMNode").returns(fakeViewElement);
 
         view.attachVideo({
-          src: {fake: 2}
+          src: { fake: 2 }
         });
 
-        expect(fakeViewElement.src).eql({fake: 2});
+        expect(fakeViewElement.src).eql({ fake: 2 });
       });
     });
   });
 
   describe("MediaLayoutView", function() {
     var textChatStore, view;
 
     function mountTestComponent(extraProps) {
@@ -1033,17 +1033,17 @@ describe("loop.shared.views", function()
           _.extend(defaultProps, extraProps)));
     }
 
     beforeEach(function() {
       textChatStore = new loop.store.TextChatStore(dispatcher, {
         sdkDriver: {}
       });
 
-      loop.store.StoreMixin.register({textChatStore: textChatStore});
+      loop.store.StoreMixin.register({ textChatStore: textChatStore });
     });
 
     it("should mark the remote stream as the focus stream when not displaying screen share", function() {
       view = mountTestComponent({
         displayScreenShare: false
       });
 
       var node = view.getDOMNode();
--- a/browser/components/loop/test/standalone/standaloneMetricsStore_test.js
+++ b/browser/components/loop/test/standalone/standaloneMetricsStore_test.js
@@ -188,17 +188,17 @@ describe("loop.store.StandaloneMetricsSt
           "send", "event", METRICS_GA_CATEGORY.general, METRICS_GA_ACTIONS.button,
           "Joined in Firefox");
       });
     });
   });
 
   describe("Store Change Handlers", function() {
     it("should log an event on room full", function() {
-      fakeActiveRoomStore.setStoreState({roomState: ROOM_STATES.FULL});
+      fakeActiveRoomStore.setStoreState({ roomState: ROOM_STATES.FULL });
 
       sinon.assert.calledOnce(window.ga);
       sinon.assert.calledWithExactly(window.ga,
         "send", "event", METRICS_GA_CATEGORY.general, METRICS_GA_ACTIONS.pageLoad,
         "Room full");
     });
 
     it("should log an event when the room is expired or invalid", function() {
--- a/browser/components/loop/test/standalone/standaloneMozLoop_test.js
+++ b/browser/components/loop/test/standalone/standaloneMozLoop_test.js
@@ -81,27 +81,27 @@ describe("loop.StandaloneMozLoop", funct
     it("should call the callback with success parameters", function() {
       mozLoop.rooms.get("fakeToken", callback);
 
       var roomDetails = {
         roomName: "fakeName",
         roomUrl: "http://invalid"
       };
 
-      requests[0].respond(200, {"Content-Type": "application/json"},
+      requests[0].respond(200, { "Content-Type": "application/json" },
         JSON.stringify(roomDetails));
 
       sinon.assert.calledOnce(callback);
       sinon.assert.calledWithExactly(callback, null, roomDetails);
     });
 
     it("should call the callback with failure parameters", function() {
       mozLoop.rooms.get("fakeToken", callback);
 
-      requests[0].respond(401, {"Content-Type": "application/json"},
+      requests[0].respond(401, { "Content-Type": "application/json" },
                           JSON.stringify(fakeServerErrorDescription));
       sinon.assert.calledWithMatch(callback, sinon.match(function(err) {
         return /HTTP 401 Unauthorized/.test(err.message);
       }));
     });
   });
 
   describe("#rooms.join", function() {
@@ -121,27 +121,27 @@ describe("loop.StandaloneMozLoop", funct
 
       var sessionData = {
         apiKey: "12345",
         sessionId: "54321",
         sessionToken: "another token",
         expires: 20
       };
 
-      requests[0].respond(200, {"Content-Type": "application/json"},
+      requests[0].respond(200, { "Content-Type": "application/json" },
         JSON.stringify(sessionData));
 
       sinon.assert.calledOnce(callback);
       sinon.assert.calledWithExactly(callback, null, sessionData);
     });
 
     it("should call the callback with failure parameters", function() {
       mozLoop.rooms.join("fakeToken", callback);
 
-      requests[0].respond(401, {"Content-Type": "application/json"},
+      requests[0].respond(401, { "Content-Type": "application/json" },
                           JSON.stringify(fakeServerErrorDescription));
       sinon.assert.calledWithMatch(callback, sinon.match(function(err) {
         return /HTTP 401 Unauthorized/.test(err.message);
       }));
     });
   });
 
   describe("#rooms.refreshMembership", function() {
@@ -179,28 +179,28 @@ describe("loop.StandaloneMozLoop", funct
     it("should call the callback with success parameters", function() {
       standaloneMozLoop.rooms.refreshMembership("fakeToken", "fakeSessionToken",
                                                 callback);
 
       var responseData = {
         expires: 20
       };
 
-      requests[0].respond(200, {"Content-Type": "application/json"},
+      requests[0].respond(200, { "Content-Type": "application/json" },
         JSON.stringify(responseData));
 
       sinon.assert.calledOnce(callback);
       sinon.assert.calledWithExactly(callback, null, responseData);
     });
 
     it("should call the callback with failure parameters", function() {
       standaloneMozLoop.rooms.refreshMembership("fakeToken", "fakeSessionToken",
                                                 callback);
 
-      requests[0].respond(401, {"Content-Type": "application/json"},
+      requests[0].respond(401, { "Content-Type": "application/json" },
                           JSON.stringify(fakeServerErrDescription));
       sinon.assert.calledWithMatch(callback, sinon.match(function(err) {
         return /HTTP 401 Unauthorized/.test(err.message);
       }));
     });
   });
 
   describe("#rooms.leave", function() {
@@ -225,16 +225,16 @@ describe("loop.StandaloneMozLoop", funct
 
       sinon.assert.calledOnce(callback);
       sinon.assert.calledWithExactly(callback, null, {});
     });
 
     it("should call the callback with failure parameters", function() {
       mozLoop.rooms.leave("fakeToken", "fakeSessionToken", callback);
 
-      requests[0].respond(401, {"Content-Type": "application/json"},
+      requests[0].respond(401, { "Content-Type": "application/json" },
                           JSON.stringify(fakeServerErrorDescription));
       sinon.assert.calledWithMatch(callback, sinon.match(function(err) {
         return /HTTP 401 Unauthorized/.test(err.message);
       }));
     });
   });
 });
--- a/browser/components/loop/test/standalone/standaloneRoomViews_test.js
+++ b/browser/components/loop/test/standalone/standaloneRoomViews_test.js
@@ -361,57 +361,57 @@ describe("loop.standaloneRoomViews", fun
     function expectActionDispatched() {
       sinon.assert.calledOnce(dispatch);
       sinon.assert.calledWithExactly(dispatch,
         sinon.match.instanceOf(sharedActions.SetupStreamElements));
     }
 
     describe("#componentWillUpdate", function() {
       it("should set document.title to roomName and brand name when the READY state is dispatched", function() {
-        activeRoomStore.setStoreState({roomName: "fakeName", roomState: ROOM_STATES.INIT});
+        activeRoomStore.setStoreState({ roomName: "fakeName", roomState: ROOM_STATES.INIT });
         view = mountTestComponent();
-        activeRoomStore.setStoreState({roomState: ROOM_STATES.READY});
+        activeRoomStore.setStoreState({ roomState: ROOM_STATES.READY });
 
         expect(fakeWindow.document.title).to.equal("fakeName — clientShortname2");
       });
 
       it("should set document.title brand name when there is no context available", function() {
-        activeRoomStore.setStoreState({roomState: ROOM_STATES.INIT});
+        activeRoomStore.setStoreState({ roomState: ROOM_STATES.INIT });
         view = mountTestComponent();
-        activeRoomStore.setStoreState({roomState: ROOM_STATES.READY});
+        activeRoomStore.setStoreState({ roomState: ROOM_STATES.READY });
 
         expect(fakeWindow.document.title).to.equal("clientShortname2");
       });
 
       it("should dispatch a `SetupStreamElements` action when the MEDIA_WAIT state " +
         "is entered", function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.READY});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.READY });
           view = mountTestComponent();
 
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.MEDIA_WAIT});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.MEDIA_WAIT });
 
           expectActionDispatched(view);
         });
 
       it("should dispatch a `SetupStreamElements` action on MEDIA_WAIT state is " +
         "re-entered", function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.ENDED});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.ENDED });
           view = mountTestComponent();
 
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.MEDIA_WAIT});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.MEDIA_WAIT });
 
           expectActionDispatched(view);
         });
     });
 
     describe("#componentDidUpdate", function() {
       beforeEach(function() {
         view = mountTestComponent();
-        activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINING});
-        activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINED});
+        activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINING });
+        activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINED });
       });
 
       it("should not dispatch a `TileShown` action immediately in the JOINED state",
         function() {
           sinon.assert.notCalled(dispatch);
         });
 
       it("should dispatch a `TileShown` action after a wait when in the JOINED state",
@@ -419,79 +419,79 @@ describe("loop.standaloneRoomViews", fun
           clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
           sinon.assert.calledOnce(dispatch);
           sinon.assert.calledWithExactly(dispatch, new sharedActions.TileShown());
         });
 
       it("should dispatch a single `TileShown` action after a wait when going through multiple waiting states",
         function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.SESSION_CONNECTED});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.SESSION_CONNECTED });
           clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
           sinon.assert.calledOnce(dispatch);
           sinon.assert.calledWithExactly(dispatch, new sharedActions.TileShown());
         });
 
       it("should not dispatch a `TileShown` action after a wait when in the HAS_PARTICIPANTS state",
         function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.HAS_PARTICIPANTS});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.HAS_PARTICIPANTS });
           clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
           sinon.assert.notCalled(dispatch);
         });
 
       it("should dispatch a `TileShown` action after a wait when a participant leaves",
         function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.HAS_PARTICIPANTS});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.HAS_PARTICIPANTS });
           clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
           activeRoomStore.remotePeerDisconnected();
           clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
           sinon.assert.calledOnce(dispatch);
           sinon.assert.calledWithExactly(dispatch, new sharedActions.TileShown());
         });
     });
 
     describe("#componentWillReceiveProps", function() {
       beforeEach(function() {
         view = mountTestComponent();
 
         // Pretend the user waited a little bit
-        activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINING});
+        activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINING });
         clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY - 1);
       });
 
       describe("Support multiple joins", function() {
         it("should send the first `TileShown` after waiting in JOINING state",
           function() {
             clock.tick(1);
 
             sinon.assert.calledOnce(dispatch);
             sinon.assert.calledWithExactly(dispatch, new sharedActions.TileShown());
           });
 
         it("should send the second `TileShown` after ending and rejoining",
           function() {
             // Trigger the first message then rejoin and wait
             clock.tick(1);
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.ENDED});
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINING});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.ENDED });
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINING });
             clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
             sinon.assert.calledTwice(dispatch);
             sinon.assert.calledWithExactly(dispatch, new sharedActions.TileShown());
           });
       });
 
       describe("Handle leaving quickly", function() {
         beforeEach(function() {
           // The user left and rejoined
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.ENDED});
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINING});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.ENDED });
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINING });
         });
 
         it("should not dispatch an old `TileShown` action after leaving and rejoining",
           function() {
             clock.tick(1);
 
             sinon.assert.notCalled(dispatch);
           });
@@ -536,115 +536,115 @@ describe("loop.standaloneRoomViews", fun
           enabled: true
         }));
       });
     });
 
     describe("#render", function() {
       beforeEach(function() {
         view = mountTestComponent();
-        activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINING});
+        activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINING });
       });
 
       describe("Empty room message", function() {
         it("should not display an message immediately in the JOINED state",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINED});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINED });
 
             expect(view.getDOMNode().querySelector(".empty-room-message"))
               .eql(null);
           });
 
         it("should display an empty room message after a wait when in the JOINED state",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINED});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINED });
             clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
             expect(view.getDOMNode().querySelector(".empty-room-message"))
               .not.eql(null);
           });
 
         it("should not display an message immediately in the SESSION_CONNECTED state",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.SESSION_CONNECTED});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.SESSION_CONNECTED });
 
             expect(view.getDOMNode().querySelector(".empty-room-message"))
               .eql(null);
           });
 
         it("should display an empty room message after a wait when in the SESSION_CONNECTED state",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.SESSION_CONNECTED});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.SESSION_CONNECTED });
             clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
             expect(view.getDOMNode().querySelector(".empty-room-message"))
               .not.eql(null);
           });
 
         it("should not display an message immediately in the HAS_PARTICIPANTS state",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.HAS_PARTICIPANTS});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.HAS_PARTICIPANTS });
 
             expect(view.getDOMNode().querySelector(".empty-room-message"))
               .eql(null);
           });
 
         it("should not display an empty room message even after a wait when in the HAS_PARTICIPANTS state",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.HAS_PARTICIPANTS});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.HAS_PARTICIPANTS });
             clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
             expect(view.getDOMNode().querySelector(".empty-room-message"))
               .eql(null);
           });
       });
 
       describe("Empty room tile offer", function() {
         it("should display a waiting room message and tile iframe on JOINED", function() {
           var DUMMY_TILE_URL = "http://tile/";
           loop.config.tilesIframeUrl = DUMMY_TILE_URL;
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINED});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINED });
           clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
           expect(view.getDOMNode().querySelector(".room-waiting-area")).not.eql(null);
 
           var tile = view.getDOMNode().querySelector(".room-waiting-tile");
           expect(tile).not.eql(null);
           expect(tile.src).eql(DUMMY_TILE_URL);
         });
 
         it("should dispatch a RecordClick action when the tile support link is clicked", function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINED});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINED });
           clock.tick(loop.standaloneRoomViews.StandaloneRoomInfoArea.RENDER_WAITING_DELAY);
 
           TestUtils.Simulate.click(view.getDOMNode().querySelector(".room-waiting-area a"));
 
           sinon.assert.calledTwice(dispatcher.dispatch);
           sinon.assert.calledWithExactly(dispatcher.dispatch,
             new sharedActions.RecordClick({
               linkInfo: "Tiles support link click"
             }));
         });
 
       });
 
       describe("Prompt media message", function() {
         it("should display a prompt for user media on MEDIA_WAIT",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.MEDIA_WAIT});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.MEDIA_WAIT });
 
             expect(view.getDOMNode().querySelector(".prompt-media-message"))
               .not.eql(null);
           });
       });
 
       describe("Full room message", function() {
         it("should display a full room message on FULL",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.FULL});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.FULL });
 
             expect(view.getDOMNode().querySelector(".full-room-message"))
               .not.eql(null);
           });
       });
 
       describe("Failed room message", function() {
         it("should display the StandaloneRoomFailureView", function() {
@@ -667,30 +667,30 @@ describe("loop.standaloneRoomViews", fun
       });
 
       describe("Join button", function() {
         function getJoinButton(elem) {
           return elem.getDOMNode().querySelector(".btn-join");
         }
 
         it("should render the Join button when room isn't active", function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.READY});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.READY });
 
           expect(getJoinButton(view)).not.eql(null);
         });
 
         it("should not render the Join button when room is active",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.SESSION_CONNECTED});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.SESSION_CONNECTED });
 
             expect(getJoinButton(view)).eql(null);
           });
 
         it("should join the room when clicking the Join button", function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.READY});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.READY });
 
           TestUtils.Simulate.click(getJoinButton(view));
 
           sinon.assert.calledOnce(dispatch);
           sinon.assert.calledWithExactly(dispatch, new sharedActions.JoinRoom());
         });
       });
 
@@ -884,58 +884,58 @@ describe("loop.standaloneRoomViews", fun
 
       describe("Leave button", function() {
         function getLeaveButton(elem) {
           return elem.getDOMNode().querySelector(".btn-hangup");
         }
 
         it("should remove the Leave button when the room state is READY",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.READY});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.READY });
 
             expect(getLeaveButton(view)).eql(null);
           });
 
         it("should remove the Leave button when the room state is FAILED",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.FAILED});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.FAILED });
 
             expect(getLeaveButton(view)).eql(null);
           });
 
         it("should remove the Leave button when the room state is FULL",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.FULL});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.FULL });
 
             expect(getLeaveButton(view)).eql(null);
           });
 
         it("should display the Leave button when the room state is SESSION_CONNECTED",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.SESSION_CONNECTED});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.SESSION_CONNECTED });
 
             expect(getLeaveButton(view)).not.eql(null);
           });
 
         it("should display the Leave button when the room state is JOINED",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.JOINED});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.JOINED });
 
             expect(getLeaveButton(view)).not.eql(null);
           });
 
         it("should display the Leave button when the room state is HAS_PARTICIPANTS",
           function() {
-            activeRoomStore.setStoreState({roomState: ROOM_STATES.HAS_PARTICIPANTS});
+            activeRoomStore.setStoreState({ roomState: ROOM_STATES.HAS_PARTICIPANTS });
 
             expect(getLeaveButton(view)).not.eql(null);
           });
 
         it("should leave the room when clicking the Leave button", function() {
-          activeRoomStore.setStoreState({roomState: ROOM_STATES.HAS_PARTICIPANTS});
+          activeRoomStore.setStoreState({ roomState: ROOM_STATES.HAS_PARTICIPANTS });
 
           TestUtils.Simulate.click(getLeaveButton(view));
 
           sinon.assert.calledOnce(dispatch);
           sinon.assert.calledWithExactly(dispatch, new sharedActions.LeaveRoom());
         });
       });
 
--- a/browser/components/loop/test/standalone/webapp_test.js
+++ b/browser/components/loop/test/standalone/webapp_test.js
@@ -97,45 +97,45 @@ describe("loop.webapp", function() {
       standaloneAppStore = new loop.store.StandaloneAppStore({
         dispatcher: dispatcher,
         sdk: sdk
       });
     });
 
     it("should display the UnsupportedDeviceView for `unsupportedDevice` window type",
       function() {
-        standaloneAppStore.setStoreState({windowType: "unsupportedDevice", unsupportedPlatform: "ios"});
+        standaloneAppStore.setStoreState({ windowType: "unsupportedDevice", unsupportedPlatform: "ios" });
         var webappRootView = mountTestComponent();
 
         TestUtils.findRenderedComponentWithType(webappRootView,
           loop.webapp.UnsupportedDeviceView);
       });
 
     it("should display the UnsupportedBrowserView for `unsupportedBrowser` window type",
       function() {
-        standaloneAppStore.setStoreState({windowType: "unsupportedBrowser", isFirefox: false});
+        standaloneAppStore.setStoreState({ windowType: "unsupportedBrowser", isFirefox: false });
 
         var webappRootView = mountTestComponent();
 
         TestUtils.findRenderedComponentWithType(webappRootView,
           loop.webapp.UnsupportedBrowserView);
       });
 
     it("should display the StandaloneRoomControllerView for `room` window type",
       function() {
-        standaloneAppStore.setStoreState({windowType: "room", isFirefox: true});
+        standaloneAppStore.setStoreState({ windowType: "room", isFirefox: true });
 
         var webappRootView = mountTestComponent();
 
         TestUtils.findRenderedComponentWithType(webappRootView,
           loop.standaloneRoomViews.StandaloneRoomControllerView);
       });
 
     it("should display the HomeView for `home` window type", function() {
-        standaloneAppStore.setStoreState({windowType: "home", isFirefox: true});
+        standaloneAppStore.setStoreState({ windowType: "home", isFirefox: true });
 
         var webappRootView = mountTestComponent();
 
         TestUtils.findRenderedComponentWithType(webappRootView,
           loop.webapp.HomeView);
     });
   });
 
--- a/browser/components/loop/test/xpcshell/head.js
+++ b/browser/components/loop/test/xpcshell/head.js
@@ -1,14 +1,14 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
-var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+var { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
 
 // Initialize this before the imports, as some of them need it.
 do_get_profile();
 
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/Http.jsm");
 Cu.import("resource://testing-common/httpd.js");
@@ -167,31 +167,31 @@ MockWebSocketChannel.prototype = {
   },
 
   sendMsg: function(aMsg) {
     var message = JSON.parse(aMsg);
 
     switch(message.messageType) {
       case "hello":
         this.listener.onMessageAvailable(this.context,
-          JSON.stringify({messageType: "hello",
-                          uaid: kUAID}));
+          JSON.stringify({ messageType: "hello",
+                          uaid: kUAID }));
         break;
       case "register":
         this.channelID = message.channelID;
         let statusCode = 200;
         if (this.initRegStatus) {
           statusCode = this.initRegStatus;
           this.initRegStatus = 0;
         }
         this.listener.onMessageAvailable(this.context,
-          JSON.stringify({messageType: "register",
+          JSON.stringify({ messageType: "register",
                           status: statusCode,
                           channelID: this.channelID,
-                          pushEndpoint: kEndPointUrl}));
+                          pushEndpoint: kEndPointUrl }));
         break;
       default:
         this.defaultMsgHandler && this.defaultMsgHandler(message);
     }
   },
 
   close: function(aCode, aReason) {
     this.stop(aCode);
--- a/browser/components/loop/test/xpcshell/test_looppush_initialize.js
+++ b/browser/components/loop/test/xpcshell/test_looppush_initialize.js
@@ -18,17 +18,17 @@ add_test(function test_initalize_missing
 });
 
 add_test(function test_initalize_missing_notifycallback() {
   Assert.throws(() => MozLoopPushHandler.register("chan-1", dummyCallback, null));
   run_next_test();
 });
 
 add_test(function test_initalize_websocket() {
-  MozLoopPushHandler.initialize({mockWebSocket: mockWebSocket});
+  MozLoopPushHandler.initialize({ mockWebSocket: mockWebSocket });
   MozLoopPushHandler.register(
     "chan-1",
     function(err, url, id) {
       Assert.equal(err, null, "err should be null to indicate success");
       Assert.equal(url, kEndPointUrl, "Should return push server application URL");
       Assert.equal(id, "chan-1", "Should have channel id = chan-1");
       Assert.equal(mockWebSocket.uri.prePath, kServerPushUrl,
                    "Should have the url from preferences");
@@ -98,17 +98,17 @@ add_test(function test_retry_registratio
   MozLoopPushHandler.uaID = undefined;
   mockWebSocket.initRegStatus = 500;
   mockWebSocket.stop();
 });
 
 add_test(function test_reconnect_no_registration() {
   let regCnt = 0;
   MozLoopPushHandler.shutdown();
-  MozLoopPushHandler.initialize({mockWebSocket: mockWebSocket});
+  MozLoopPushHandler.initialize({ mockWebSocket: mockWebSocket });
   MozLoopPushHandler.register(
     "test-chan",
     function(err, url, id) {
       Assert.equal(++regCnt, 1, "onRegistered should only be called once");
       Assert.equal(err, null, "err should be null to indicate success");
       Assert.equal(url, kEndPointUrl, "Should return push server application URL");
       Assert.equal(id, "test-chan", "Should have channel id = test-chan");
       mockWebSocket.stop();
@@ -125,17 +125,17 @@ add_test(function test_ping_websocket() 
     pingReceived = true;
     // Do not send a ping response.
   };
   mockWebSocket.close = () => {
     socketClosed = true;
   };
 
   MozLoopPushHandler.shutdown();
-  MozLoopPushHandler.initialize({mockWebSocket: mockWebSocket});
+  MozLoopPushHandler.initialize({ mockWebSocket: mockWebSocket });
   MozLoopPushHandler.register(
     "test-chan",
     function(err, url) {
       Assert.equal(err, null, "err should be null to indicate success");
       waitForCondition(() => pingReceived).then(() => {
         waitForCondition(() => socketClosed).then(() => {
           run_next_test();
         }, () => {
@@ -159,46 +159,46 @@ add_test(function test_retry_pushurl() {
       // Non-200 response
       response.setStatusLine(null, 500, "Retry");
       response.processAsync();
       response.finish();
       break;
     case 2:
       // missing parameter
       response.setStatusLine(null, 200, "OK");
-      response.write(JSON.stringify({pushServerURI: null}));
+      response.write(JSON.stringify({ pushServerURI: null }));
       response.processAsync();
       response.finish();
       break;
     case 3:
       // json parse error
       response.setStatusLine(null, 200, "OK");
       response.processAsync();
       response.finish();
       break;
     case 4:
       response.setStatusLine(null, 200, "OK");
-      response.write(JSON.stringify({pushServerURI: kServerPushUrl}));
+      response.write(JSON.stringify({ pushServerURI: kServerPushUrl }));
       response.processAsync();
       response.finish();
 
       run_next_test();
       break;
     }
   });
 
-  MozLoopPushHandler.initialize({mockWebSocket: mockWebSocket});
+  MozLoopPushHandler.initialize({ mockWebSocket: mockWebSocket });
 });
 
 function run_test() {
   setupFakeLoopServer();
 
   loopServer.registerPathHandler("/push-server-config", (request, response) => {
     response.setStatusLine(null, 200, "OK");
-    response.write(JSON.stringify({pushServerURI: kServerPushUrl}));
+    response.write(JSON.stringify({ pushServerURI: kServerPushUrl }));
     response.processAsync();
     response.finish();
   });
 
   Services.prefs.setCharPref("services.push.serverURL", kServerPushUrl);
   Services.prefs.setIntPref("loop.retry_delay.start", 10); // 10 ms
   Services.prefs.setIntPref("loop.retry_delay.limit", 20); // 20 ms
   Services.prefs.setIntPref("loop.ping.interval", 50); // 50 ms
--- a/browser/components/loop/test/xpcshell/test_looprooms_encryption_in_fxa.js
+++ b/browser/components/loop/test/xpcshell/test_looprooms_encryption_in_fxa.js
@@ -196,17 +196,17 @@ add_task(function* test_get_rooms_saves_
 
   yield clearRoomsCache();
 });
 
 // Test that when we get a room it updates the saved key if it is different.
 add_task(function* test_get_rooms_saves_different_keys() {
   let roomsCache = {};
   roomsCache[LOOP_SESSION_TYPE.FXA] = {
-    QzBbvGmIZWU: {key: "fakeKey"}
+    QzBbvGmIZWU: { key: "fakeKey" }
   };
   yield saveRoomsCache(roomsCache);
 
   const kRoomToken = "QzBbvGmIZWU";
 
   let room = yield LoopRooms.promise("get", kRoomToken);
 
   // Check that we've saved the encryption keys correctly.
@@ -220,17 +220,17 @@ add_task(function* test_get_rooms_saves_
 
 // Test that if roomKey decryption fails, the saved key is used for decryption.
 add_task(function* test_get_rooms_uses_saved_key() {
   const kRoomToken = "_nxD4V4FflQ";
   const kExpected = kExpectedRooms.get(kRoomToken);
 
   let roomsCache = {};
   roomsCache[LOOP_SESSION_TYPE.FXA] = {
-    "_nxD4V4FflQ": {key: kExpected.roomKey}
+    "_nxD4V4FflQ": { key: kExpected.roomKey }
   };
   yield saveRoomsCache(roomsCache);
 
   // Change the encryption key for FxA, so that decoding the room key will break.
   Services.prefs.setCharPref("loop.key.fxa", "invalidKey");
 
   let room = yield LoopRooms.promise("get", kRoomToken);
 
--- a/browser/components/loop/test/xpcshell/test_looprooms_upgrade_to_encryption.js
+++ b/browser/components/loop/test/xpcshell/test_looprooms_upgrade_to_encryption.js
@@ -7,17 +7,17 @@
 Cu.import("resource://services-common/utils.js");
 
 const loopCrypto = Cu.import("resource:///modules/loop/crypto.js", {}).LoopCrypto;
 const { LOOP_ROOMS_CACHE_FILENAME } = Cu.import("resource:///modules/loop/LoopRoomsCache.jsm", {});
 
 var gTimerArgs = [];
 
 timerHandlers.startTimer = function(callback, delay) {
-  gTimerArgs.push({callback, delay});
+  gTimerArgs.push({ callback, delay });
   return gTimerArgs.length;
 };
 
 var gRoomPatches = [];
 
 const kContextEnabledPref = "loop.contextInConverations.enabled";
 
 const kFxAKey = "uGIs-kGbYt1hBBwjyW7MLQ";
--- a/browser/components/loop/test/xpcshell/test_loopservice_dnd.js
+++ b/browser/components/loop/test/xpcshell/test_loopservice_dnd.js
@@ -37,17 +37,17 @@ function run_test() {
 
   loopServer.registerPathHandler("/registration", (request, response) => {
     response.setStatusLine(null, 200, "OK");
     response.processAsync();
     response.finish();
   });
   loopServer.registerPathHandler("/calls", (request, response) => {
     response.setStatusLine(null, 200, "OK");
-    response.write(JSON.stringify({calls: [{callId: 4444333221, websocketToken: "0deadbeef0"}]}));
+    response.write(JSON.stringify({ calls: [{ callId: 4444333221, websocketToken: "0deadbeef0" }] }));
     response.processAsync();
     response.finish();
   });
 
   do_register_cleanup(function() {
     // Revert original Chat.open implementation
     Chat.open = openChatOrig;
 
--- a/browser/components/loop/test/xpcshell/test_loopservice_hawk_request.js
+++ b/browser/components/loop/test/xpcshell/test_loopservice_hawk_request.js
@@ -17,17 +17,17 @@ add_task(function* request_with_unicode(
     let jsonBody = JSON.parse(body);
     Assert.equal(jsonBody.name, CommonUtils.encodeUTF8(unicodeName));
 
     response.setStatusLine(null, 200, "OK");
     response.processAsync();
     response.finish();
   });
 
-  yield MozLoopServiceInternal.hawkRequestInternal(LOOP_SESSION_TYPE.GUEST, "/fake", "POST", {name: unicodeName}).then(
+  yield MozLoopServiceInternal.hawkRequestInternal(LOOP_SESSION_TYPE.GUEST, "/fake", "POST", { name: unicodeName }).then(
     () => Assert.ok(true, "Should have accepted"),
     () => Assert.ok(false, "Should have accepted"));
 });
 
 function run_test() {
   setupFakeLoopServer();
 
   do_register_cleanup(() => {
--- a/browser/components/loop/ui/ui-showcase.js
+++ b/browser/components/loop/ui/ui-showcase.js
@@ -136,22 +136,22 @@
         // the dimensions here are taken from the poster images that we're
         // using, since they give the <video> elements their initial intrinsic
         // size.  This ensures that the right aspect ratios are calculated.
         // These are forced to 640x480, because it makes it visually easy to
         // validate that the showcase looks like the real app on a chine
         // (eg MacBook Pro) where that is the default camera resolution.
         var newStoreState = {
           localVideoDimensions: {
-            camera: {height: 480, orientation: 0, width: 640}
+            camera: { height: 480, orientation: 0, width: 640 }
           },
           mediaConnected: options.mediaConnected,
           receivingScreenShare: !!options.receivingScreenShare,
           remoteVideoDimensions: {
-            camera: {height: 480, orientation: 0, width: 640}
+            camera: { height: 480, orientation: 0, width: 640 }
           },
           remoteVideoEnabled: options.remoteVideoEnabled,
           // Override the matchMedia, this is so that the correct version is
           // used for the frame.
           //
           // Currently, we use an icky hack, and the showcase conspires with
           // react-frame-component to set iframe.contentWindow.matchMedia onto
           // the store. Once React context matures a bit (somewhere between
@@ -167,17 +167,17 @@
 
         if (options.receivingScreenShare) {
           // Note that the image we're using had to be scaled a bit, and
           // it still ended up a bit narrower than the live thing that
           // WebRTC sends; presumably a different scaling algorithm.
           // For showcase purposes, this shouldn't matter much, as the sizes
           // of things being shared will be fairly arbitrary.
           newStoreState.remoteVideoDimensions.screen =
-          {height: 456, orientation: 0, width: 641};
+          { height: 456, orientation: 0, width: 641 };
         }
 
         store.setStoreState(newStoreState);
       } catch (ex) {
         console.error("exception in forcedUpdate:", ex);
       }
     };
 
@@ -334,17 +334,17 @@
     roomUrl: "http://showcase",
     urls: [{
       description: "A wonderful page!",
       location: "http://wonderful.invalid"
       // use the fallback thumbnail
     }]
   }));
 
-  textChatStore.setStoreState({textChatEnabled: true});
+  textChatStore.setStoreState({ textChatEnabled: true });
 
   dispatcher.dispatch(new sharedActions.SendTextChatMessage({
     contentType: loop.shared.utils.CHAT_CONTENT_TYPES.TEXT,
     message: "Rheet!",
     sentTimestamp: "2015-06-23T22:21:45.590Z"
   }));
   dispatcher.dispatch(new sharedActions.ReceivedTextChatMessage({
     contentType: loop.shared.utils.CHAT_CONTENT_TYPES.TEXT,
@@ -548,17 +548,17 @@
       var cx = React.addons.classSet;
       return (
         React.createElement("div", {className: "example"}, 
           React.createElement("h3", {id: this.makeId()}, 
             this.props.summary, 
             React.createElement("a", {href: this.makeId("#")}, " ¶")
           ), 
           React.createElement("div", {className: "comp"}, 
-            React.createElement(Frame, {className: cx({dashed: this.props.dashed}), 
+            React.createElement(Frame, {className: cx({ dashed: this.props.dashed }), 
                    cssClass: this.props.cssClass, 
                    height: height, 
                    onContentsRendered: this.props.onContentsRendered, 
                    width: width}, 
               this.props.children
             )
           )
         )
@@ -1316,17 +1316,17 @@
       caughtWarnings.push(args);
       consoleWarn.apply(console, args);
     };
 
     try {
       React.render(React.createElement(App, null), document.getElementById("main"));
 
       for (var listener of visibilityListeners) {
-        listener({target: {hidden: false}});
+        listener({ target: { hidden: false } });
       }
     } catch(err) {
       console.error(err);
       uncaughtError = err;
     }
 
     // Wait until all the FramedExamples have been fully loaded.
     setTimeout(function waitForQueuedFrames() {
--- a/browser/components/loop/ui/ui-showcase.jsx
+++ b/browser/components/loop/ui/ui-showcase.jsx
@@ -136,22 +136,22 @@
         // the dimensions here are taken from the poster images that we're
         // using, since they give the <video> elements their initial intrinsic
         // size.  This ensures that the right aspect ratios are calculated.
         // These are forced to 640x480, because it makes it visually easy to
         // validate that the showcase looks like the real app on a chine
         // (eg MacBook Pro) where that is the default camera resolution.
         var newStoreState = {
           localVideoDimensions: {
-            camera: {height: 480, orientation: 0, width: 640}
+            camera: { height: 480, orientation: 0, width: 640 }
           },
           mediaConnected: options.mediaConnected,
           receivingScreenShare: !!options.receivingScreenShare,
           remoteVideoDimensions: {
-            camera: {height: 480, orientation: 0, width: 640}
+            camera: { height: 480, orientation: 0, width: 640 }
           },
           remoteVideoEnabled: options.remoteVideoEnabled,
           // Override the matchMedia, this is so that the correct version is
           // used for the frame.
           //
           // Currently, we use an icky hack, and the showcase conspires with
           // react-frame-component to set iframe.contentWindow.matchMedia onto
           // the store. Once React context matures a bit (somewhere between
@@ -167,17 +167,17 @@
 
         if (options.receivingScreenShare) {
           // Note that the image we're using had to be scaled a bit, and
           // it still ended up a bit narrower than the live thing that
           // WebRTC sends; presumably a different scaling algorithm.
           // For showcase purposes, this shouldn't matter much, as the sizes
           // of things being shared will be fairly arbitrary.
           newStoreState.remoteVideoDimensions.screen =
-          {height: 456, orientation: 0, width: 641};
+          { height: 456, orientation: 0, width: 641 };
         }
 
         store.setStoreState(newStoreState);
       } catch (ex) {
         console.error("exception in forcedUpdate:", ex);
       }
     };
 
@@ -334,17 +334,17 @@
     roomUrl: "http://showcase",
     urls: [{
       description: "A wonderful page!",
       location: "http://wonderful.invalid"
       // use the fallback thumbnail
     }]
   }));
 
-  textChatStore.setStoreState({textChatEnabled: true});
+  textChatStore.setStoreState({ textChatEnabled: true });
 
   dispatcher.dispatch(new sharedActions.SendTextChatMessage({
     contentType: loop.shared.utils.CHAT_CONTENT_TYPES.TEXT,
     message: "Rheet!",
     sentTimestamp: "2015-06-23T22:21:45.590Z"
   }));
   dispatcher.dispatch(new sharedActions.ReceivedTextChatMessage({
     contentType: loop.shared.utils.CHAT_CONTENT_TYPES.TEXT,
@@ -548,17 +548,17 @@
       var cx = React.addons.classSet;
       return (
         <div className="example">
           <h3 id={this.makeId()}>
             {this.props.summary}
             <a href={this.makeId("#")}>&nbsp;¶</a>
           </h3>
           <div className="comp">
-            <Frame className={cx({dashed: this.props.dashed})}
+            <Frame className={cx({ dashed: this.props.dashed })}
                    cssClass={this.props.cssClass}
                    height={height}
                    onContentsRendered={this.props.onContentsRendered}
                    width={width}>
               {this.props.children}
             </Frame>
           </div>
         </div>
@@ -1316,17 +1316,17 @@
       caughtWarnings.push(args);
       consoleWarn.apply(console, args);
     };
 
     try {
       React.render(<App />, document.getElementById("main"));
 
       for (var listener of visibilityListeners) {
-        listener({target: {hidden: false}});
+        listener({ target: { hidden: false } });
       }
     } catch(err) {
       console.error(err);
       uncaughtError = err;
     }
 
     // Wait until all the FramedExamples have been fully loaded.
     setTimeout(function waitForQueuedFrames() {