Bug 1385817 - Enable the quotes ESLint rule for accessible/ r=yzen
authorDan Banner <dbugs@thebanners.uk>
Tue, 01 Aug 2017 17:13:27 +0100
changeset 422158 2439d45c93be640c6cf4c1005a4302ee75aa3cee
parent 422157 105df91f59e5db011f17c959332c6662da007eca
child 422159 f3cdf0e12b8ae34333fb240a3acf37e42d893f79
push id7761
push userjlund@mozilla.com
push dateFri, 15 Sep 2017 00:19:52 +0000
treeherdermozilla-beta@c38455951db4 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersyzen
bugs1385817
milestone57.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 1385817 - Enable the quotes ESLint rule for accessible/ r=yzen MozReview-Commit-ID: 1pS6xMzeh82
accessible/.eslintrc.js
accessible/jsat/AccessFu.jsm
accessible/jsat/Constants.jsm
accessible/jsat/ContentControl.jsm
accessible/jsat/EventManager.jsm
accessible/jsat/Gestures.jsm
accessible/jsat/OutputGenerator.jsm
accessible/jsat/PointerAdapter.jsm
accessible/jsat/Presentation.jsm
accessible/jsat/Traversal.jsm
accessible/jsat/Utils.jsm
accessible/jsat/content-script.js
accessible/tests/browser/bounds/browser_test_zoom.js
accessible/tests/browser/bounds/browser_test_zoom_text.js
accessible/tests/browser/bounds/head.js
accessible/tests/browser/browser_shutdown_acc_reference.js
accessible/tests/browser/browser_shutdown_doc_acc_reference.js
accessible/tests/browser/browser_shutdown_multi_acc_reference_doc.js
accessible/tests/browser/browser_shutdown_multi_acc_reference_obj.js
accessible/tests/browser/browser_shutdown_multi_proxy_acc_reference_doc.js
accessible/tests/browser/browser_shutdown_multi_proxy_acc_reference_obj.js
accessible/tests/browser/browser_shutdown_multi_reference.js
accessible/tests/browser/browser_shutdown_parent_own_reference.js
accessible/tests/browser/browser_shutdown_proxy_acc_reference.js
accessible/tests/browser/browser_shutdown_proxy_doc_acc_reference.js
accessible/tests/browser/browser_shutdown_remote_no_reference.js
accessible/tests/browser/browser_shutdown_remote_only.js
accessible/tests/browser/browser_shutdown_remote_own_reference.js
accessible/tests/browser/browser_shutdown_scope_lifecycle.js
accessible/tests/browser/browser_shutdown_start_restart.js
accessible/tests/browser/e10s/browser_caching_attributes.js
accessible/tests/browser/e10s/browser_caching_description.js
accessible/tests/browser/e10s/browser_caching_name.js
accessible/tests/browser/e10s/browser_caching_relations.js
accessible/tests/browser/e10s/browser_caching_states.js
accessible/tests/browser/e10s/browser_caching_value.js
accessible/tests/browser/e10s/browser_events_caretmove.js
accessible/tests/browser/e10s/browser_events_hide.js
accessible/tests/browser/e10s/browser_events_show.js
accessible/tests/browser/e10s/browser_events_statechange.js
accessible/tests/browser/e10s/browser_events_textchange.js
accessible/tests/browser/e10s/browser_treeupdate_ariadialog.js
accessible/tests/browser/e10s/browser_treeupdate_ariaowns.js
accessible/tests/browser/e10s/browser_treeupdate_canvas.js
accessible/tests/browser/e10s/browser_treeupdate_cssoverflow.js
accessible/tests/browser/e10s/browser_treeupdate_doc.js
accessible/tests/browser/e10s/browser_treeupdate_gencontent.js
accessible/tests/browser/e10s/browser_treeupdate_hidden.js
accessible/tests/browser/e10s/browser_treeupdate_imagemap.js
accessible/tests/browser/e10s/browser_treeupdate_list.js
accessible/tests/browser/e10s/browser_treeupdate_list_editabledoc.js
accessible/tests/browser/e10s/browser_treeupdate_listener.js
accessible/tests/browser/e10s/browser_treeupdate_optgroup.js
accessible/tests/browser/e10s/browser_treeupdate_removal.js
accessible/tests/browser/e10s/browser_treeupdate_table.js
accessible/tests/browser/e10s/browser_treeupdate_textleaf.js
accessible/tests/browser/e10s/browser_treeupdate_visibility.js
accessible/tests/browser/e10s/browser_treeupdate_whitespace.js
accessible/tests/browser/e10s/head.js
accessible/tests/browser/events.js
accessible/tests/browser/events/browser_test_docload.js
accessible/tests/browser/events/browser_test_focus_browserui.js
accessible/tests/browser/events/browser_test_focus_dialog.js
accessible/tests/browser/events/head.js
accessible/tests/browser/head.js
accessible/tests/browser/scroll/browser_test_zoom_text.js
accessible/tests/browser/scroll/head.js
accessible/tests/browser/shared-head.js
accessible/tests/browser/states/browser_test_link.js
accessible/tests/browser/states/browser_test_visibility.js
accessible/tests/browser/states/head.js
accessible/tests/browser/tree/head.js
accessible/tests/crashtests/448064.xhtml
accessible/tests/mochitest/aom/test_general.html
accessible/tests/mochitest/attributes/test_dpub_aria_xml-roles.html
accessible/tests/mochitest/common.js
accessible/tests/mochitest/elm/test_canvas.html
accessible/tests/mochitest/elm/test_shadowroot.html
accessible/tests/mochitest/events/docload_wnd.html
accessible/tests/mochitest/events/test_coalescence.html
accessible/tests/mochitest/events/test_focus_general.html
accessible/tests/mochitest/events/test_mutation.html
accessible/tests/mochitest/events/test_statechange.html
accessible/tests/mochitest/hittest/test_canvas_hitregion.html
accessible/tests/mochitest/hittest/test_shadowroot.html
accessible/tests/mochitest/jsat/doc_content_integration.html
accessible/tests/mochitest/jsat/dom_helper.js
accessible/tests/mochitest/jsat/jsatcommon.js
accessible/tests/mochitest/jsat/output.js
accessible/tests/mochitest/jsat/test_alive.html
accessible/tests/mochitest/jsat/test_content_integration.html
accessible/tests/mochitest/jsat/test_content_text.html
accessible/tests/mochitest/jsat/test_hints.html
accessible/tests/mochitest/jsat/test_live_regions.html
accessible/tests/mochitest/jsat/test_pointer_relay.html
accessible/tests/mochitest/jsat/test_quicknav_modes.html
accessible/tests/mochitest/jsat/test_traversal.html
accessible/tests/mochitest/jsat/test_traversal_helper.html
accessible/tests/mochitest/name/markup.js
accessible/tests/mochitest/name/test_counterstyle.html
accessible/tests/mochitest/pivot.js
accessible/tests/mochitest/pivot/test_virtualcursor.html
accessible/tests/mochitest/pivot/test_virtualcursor_text.html
accessible/tests/mochitest/states/test_inputs.html
accessible/tests/mochitest/treeupdate/test_ariaowns.html
accessible/tests/mochitest/treeupdate/test_bug1276857.html
accessible/tests/mochitest/treeupdate/test_doc.html
accessible/tests/mochitest/treeupdate/test_general.html
accessible/tests/mochitest/treeupdate/test_select.html
npm-shrinkwrap.json
--- a/accessible/.eslintrc.js
+++ b/accessible/.eslintrc.js
@@ -5,17 +5,16 @@ module.exports = {
     // Warn about cyclomatic complexity in functions.
     "complexity": ["error", 42],
 
     // XXX These are rules that are enabled in the recommended configuration, but
     // disabled here due to failures when initially implemented. They should be
     // removed (and hence enabled) at some stage.
     "brace-style": "off",
     "consistent-return": "off",
-    "quotes": "off",
     "object-shorthand": "off",
     "space-before-function-paren": "off",
     "space-infix-ops": "off",
     "no-else-return": "off",
     "no-multi-spaces": "off",
     "no-unexpected-multiline": "off",
     "no-unsafe-finally": "off",
     "no-useless-call": "off",
--- a/accessible/jsat/AccessFu.jsm
+++ b/accessible/jsat/AccessFu.jsm
@@ -1,65 +1,65 @@
 /* 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/. */
 
 /* exported AccessFu */
 
-'use strict';
+"use strict";
 
 const {utils: Cu, interfaces: Ci} = Components;
 
-this.EXPORTED_SYMBOLS = ['AccessFu']; // jshint ignore:line
+this.EXPORTED_SYMBOLS = ["AccessFu"]; // jshint ignore:line
 
-Cu.import('resource://gre/modules/Services.jsm');
-Cu.import('resource://gre/modules/accessibility/Utils.jsm');
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/accessibility/Utils.jsm");
 
-if (Utils.MozBuildApp === 'mobile/android') {
-  Cu.import('resource://gre/modules/Messaging.jsm');
+if (Utils.MozBuildApp === "mobile/android") {
+  Cu.import("resource://gre/modules/Messaging.jsm");
 }
 
 const ACCESSFU_DISABLE = 0; // jshint ignore:line
 const ACCESSFU_ENABLE = 1;
 const ACCESSFU_AUTO = 2;
 
-const SCREENREADER_SETTING = 'accessibility.screenreader';
-const QUICKNAV_MODES_PREF = 'accessibility.accessfu.quicknav_modes';
-const QUICKNAV_INDEX_PREF = 'accessibility.accessfu.quicknav_index';
+const SCREENREADER_SETTING = "accessibility.screenreader";
+const QUICKNAV_MODES_PREF = "accessibility.accessfu.quicknav_modes";
+const QUICKNAV_INDEX_PREF = "accessibility.accessfu.quicknav_index";
 
 this.AccessFu = { // jshint ignore:line
   /**
    * Initialize chrome-layer accessibility functionality.
    * If accessibility is enabled on the platform, then a special accessibility
    * mode is started.
    */
   attach: function attach(aWindow) {
     Utils.init(aWindow);
 
-    if (Utils.MozBuildApp === 'mobile/android') {
-      EventDispatcher.instance.dispatch('Accessibility:Ready');
-      EventDispatcher.instance.registerListener(this, 'Accessibility:Settings');
+    if (Utils.MozBuildApp === "mobile/android") {
+      EventDispatcher.instance.dispatch("Accessibility:Ready");
+      EventDispatcher.instance.registerListener(this, "Accessibility:Settings");
     }
 
     this._activatePref = new PrefCache(
-      'accessibility.accessfu.activate', this._enableOrDisable.bind(this));
+      "accessibility.accessfu.activate", this._enableOrDisable.bind(this));
 
     this._enableOrDisable();
   },
 
   /**
    * Shut down chrome-layer accessibility functionality from the outside.
    */
   detach: function detach() {
     // Avoid disabling twice.
     if (this._enabled) {
       this._disable();
     }
-    if (Utils.MozBuildApp === 'mobile/android') {
-      EventDispatcher.instance.unregisterListener(this, 'Accessibility:Settings');
+    if (Utils.MozBuildApp === "mobile/android") {
+      EventDispatcher.instance.unregisterListener(this, "Accessibility:Settings");
     }
     delete this._activatePref;
     Utils.uninit();
   },
 
   /**
    * A lazy getter for event handler that binds the scope to AccessFu object.
    */
@@ -74,29 +74,29 @@ this.AccessFu = { // jshint ignore:line
    * with arrow keys.
    */
   _enable: function _enable() {
     if (this._enabled) {
       return;
     }
     this._enabled = true;
 
-    Cu.import('resource://gre/modules/accessibility/Utils.jsm');
-    Cu.import('resource://gre/modules/accessibility/PointerAdapter.jsm');
-    Cu.import('resource://gre/modules/accessibility/Presentation.jsm');
+    Cu.import("resource://gre/modules/accessibility/Utils.jsm");
+    Cu.import("resource://gre/modules/accessibility/PointerAdapter.jsm");
+    Cu.import("resource://gre/modules/accessibility/Presentation.jsm");
 
     for (let mm of Utils.AllMessageManagers) {
       this._addMessageListeners(mm);
       this._loadFrameScript(mm);
     }
 
     // Add stylesheet
-    let stylesheetURL = 'chrome://global/content/accessibility/AccessFu.css';
+    let stylesheetURL = "chrome://global/content/accessibility/AccessFu.css";
     let stylesheet = Utils.win.document.createProcessingInstruction(
-      'xml-stylesheet', 'href="' + stylesheetURL + '" type="text/css"');
+      "xml-stylesheet", `href="${stylesheetURL}" type="text/css"`);
     Utils.win.document.insertBefore(stylesheet, Utils.win.document.firstChild);
     this.stylesheet = Cu.getWeakReference(stylesheet);
 
 
     // Populate quicknav modes
     this._quicknavModesPref =
       new PrefCache(QUICKNAV_MODES_PREF, (aName, aValue, aFirstRun) => {
         this.Input.quickNavMode.updateModes(aValue);
@@ -108,139 +108,139 @@ this.AccessFu = { // jshint ignore:line
 
     this._quicknavCurrentModePref =
       new PrefCache(QUICKNAV_INDEX_PREF, (aName, aValue) => {
         this.Input.quickNavMode.updateCurrentMode(Number(aValue));
       }, true);
 
     // Check for output notification
     this._notifyOutputPref =
-      new PrefCache('accessibility.accessfu.notify_output');
+      new PrefCache("accessibility.accessfu.notify_output");
 
 
     this.Input.start();
     Output.start();
     PointerAdapter.start();
 
-    if (Utils.MozBuildApp === 'mobile/android') {
+    if (Utils.MozBuildApp === "mobile/android") {
       EventDispatcher.instance.registerListener(this, [
-        'Accessibility:ActivateObject',
-        'Accessibility:Focus',
-        'Accessibility:LongPress',
-        'Accessibility:MoveByGranularity',
-        'Accessibility:NextObject',
-        'Accessibility:PreviousObject',
-        'Accessibility:ScrollBackward',
-        'Accessibility:ScrollForward',
+        "Accessibility:ActivateObject",
+        "Accessibility:Focus",
+        "Accessibility:LongPress",
+        "Accessibility:MoveByGranularity",
+        "Accessibility:NextObject",
+        "Accessibility:PreviousObject",
+        "Accessibility:ScrollBackward",
+        "Accessibility:ScrollForward",
       ]);
     }
 
-    Services.obs.addObserver(this, 'remote-browser-shown');
-    Services.obs.addObserver(this, 'inprocess-browser-shown');
-    Utils.win.addEventListener('TabOpen', this);
-    Utils.win.addEventListener('TabClose', this);
-    Utils.win.addEventListener('TabSelect', this);
+    Services.obs.addObserver(this, "remote-browser-shown");
+    Services.obs.addObserver(this, "inprocess-browser-shown");
+    Utils.win.addEventListener("TabOpen", this);
+    Utils.win.addEventListener("TabClose", this);
+    Utils.win.addEventListener("TabSelect", this);
 
     if (this.readyCallback) {
       this.readyCallback();
       delete this.readyCallback;
     }
 
-    Logger.info('AccessFu:Enabled');
+    Logger.info("AccessFu:Enabled");
   },
 
   /**
    * Disable AccessFu and return to default interaction mode.
    */
   _disable: function _disable() {
     if (!this._enabled) {
       return;
     }
 
     this._enabled = false;
 
     Utils.win.document.removeChild(this.stylesheet.get());
 
     for (let mm of Utils.AllMessageManagers) {
-      mm.sendAsyncMessage('AccessFu:Stop');
+      mm.sendAsyncMessage("AccessFu:Stop");
       this._removeMessageListeners(mm);
     }
 
     this.Input.stop();
     Output.stop();
     PointerAdapter.stop();
 
-    Utils.win.removeEventListener('TabOpen', this);
-    Utils.win.removeEventListener('TabClose', this);
-    Utils.win.removeEventListener('TabSelect', this);
+    Utils.win.removeEventListener("TabOpen", this);
+    Utils.win.removeEventListener("TabClose", this);
+    Utils.win.removeEventListener("TabSelect", this);
 
-    Services.obs.removeObserver(this, 'remote-browser-shown');
-    Services.obs.removeObserver(this, 'inprocess-browser-shown');
+    Services.obs.removeObserver(this, "remote-browser-shown");
+    Services.obs.removeObserver(this, "inprocess-browser-shown");
 
-    if (Utils.MozBuildApp === 'mobile/android') {
+    if (Utils.MozBuildApp === "mobile/android") {
       EventDispatcher.instance.unregisterListener(this, [
-        'Accessibility:ActivateObject',
-        'Accessibility:Focus',
-        'Accessibility:LongPress',
-        'Accessibility:MoveByGranularity',
-        'Accessibility:NextObject',
-        'Accessibility:PreviousObject',
-        'Accessibility:ScrollBackward',
-        'Accessibility:ScrollForward',
+        "Accessibility:ActivateObject",
+        "Accessibility:Focus",
+        "Accessibility:LongPress",
+        "Accessibility:MoveByGranularity",
+        "Accessibility:NextObject",
+        "Accessibility:PreviousObject",
+        "Accessibility:ScrollBackward",
+        "Accessibility:ScrollForward",
       ]);
     }
 
     delete this._quicknavModesPref;
     delete this._notifyOutputPref;
 
     if (this.doneCallback) {
       this.doneCallback();
       delete this.doneCallback;
     }
 
-    Logger.info('AccessFu:Disabled');
+    Logger.info("AccessFu:Disabled");
   },
 
   _enableOrDisable: function _enableOrDisable() {
     try {
       if (!this._activatePref) {
         return;
       }
       let activatePref = this._activatePref.value;
       if (activatePref == ACCESSFU_ENABLE ||
           this._systemPref && activatePref == ACCESSFU_AUTO) {
         this._enable();
       } else {
         this._disable();
       }
     } catch (x) {
-      dump('Error ' + x.message + ' ' + x.fileName + ':' + x.lineNumber);
+      dump("Error " + x.message + " " + x.fileName + ":" + x.lineNumber);
     }
   },
 
   receiveMessage: function receiveMessage(aMessage) {
     Logger.debug(() => {
-      return ['Recieved', aMessage.name, JSON.stringify(aMessage.json)];
+      return ["Recieved", aMessage.name, JSON.stringify(aMessage.json)];
     });
 
     switch (aMessage.name) {
-      case 'AccessFu:Ready':
+      case "AccessFu:Ready":
         let mm = Utils.getMessageManager(aMessage.target);
         if (this._enabled) {
-          mm.sendAsyncMessage('AccessFu:Start',
-                              {method: 'start', buildApp: Utils.MozBuildApp});
+          mm.sendAsyncMessage("AccessFu:Start",
+                              {method: "start", buildApp: Utils.MozBuildApp});
         }
         break;
-      case 'AccessFu:Present':
+      case "AccessFu:Present":
         this._output(aMessage.json, aMessage.target);
         break;
-      case 'AccessFu:Input':
+      case "AccessFu:Input":
         this.Input.setEditState(aMessage.json);
         break;
-      case 'AccessFu:DoScroll':
+      case "AccessFu:DoScroll":
         this.Input.doScroll(aMessage.json);
         break;
     }
   },
 
   _output: function _output(aPresentationData, aBrowser) {
     if (!Utils.isAliveAndVisible(
       Utils.AccService.getAccessibleFor(aBrowser))) {
@@ -254,139 +254,139 @@ this.AccessFu = { // jshint ignore:line
       try {
         Output[presenter.type](presenter.details, aBrowser);
       } catch (x) {
         Logger.logException(x);
       }
     }
 
     if (this._notifyOutputPref.value) {
-      Services.obs.notifyObservers(null, 'accessibility-output',
+      Services.obs.notifyObservers(null, "accessibility-output",
                                    JSON.stringify(aPresentationData));
     }
   },
 
   _loadFrameScript: function _loadFrameScript(aMessageManager) {
     if (this._processedMessageManagers.indexOf(aMessageManager) < 0) {
       aMessageManager.loadFrameScript(
-        'chrome://global/content/accessibility/content-script.js', true);
+        "chrome://global/content/accessibility/content-script.js", true);
       this._processedMessageManagers.push(aMessageManager);
     } else if (this._enabled) {
       // If the content-script is already loaded and AccessFu is enabled,
       // send an AccessFu:Start message.
-      aMessageManager.sendAsyncMessage('AccessFu:Start',
-        {method: 'start', buildApp: Utils.MozBuildApp});
+      aMessageManager.sendAsyncMessage("AccessFu:Start",
+        {method: "start", buildApp: Utils.MozBuildApp});
     }
   },
 
   _addMessageListeners: function _addMessageListeners(aMessageManager) {
-    aMessageManager.addMessageListener('AccessFu:Present', this);
-    aMessageManager.addMessageListener('AccessFu:Input', this);
-    aMessageManager.addMessageListener('AccessFu:Ready', this);
-    aMessageManager.addMessageListener('AccessFu:DoScroll', this);
+    aMessageManager.addMessageListener("AccessFu:Present", this);
+    aMessageManager.addMessageListener("AccessFu:Input", this);
+    aMessageManager.addMessageListener("AccessFu:Ready", this);
+    aMessageManager.addMessageListener("AccessFu:DoScroll", this);
   },
 
   _removeMessageListeners: function _removeMessageListeners(aMessageManager) {
-    aMessageManager.removeMessageListener('AccessFu:Present', this);
-    aMessageManager.removeMessageListener('AccessFu:Input', this);
-    aMessageManager.removeMessageListener('AccessFu:Ready', this);
-    aMessageManager.removeMessageListener('AccessFu:DoScroll', this);
+    aMessageManager.removeMessageListener("AccessFu:Present", this);
+    aMessageManager.removeMessageListener("AccessFu:Input", this);
+    aMessageManager.removeMessageListener("AccessFu:Ready", this);
+    aMessageManager.removeMessageListener("AccessFu:DoScroll", this);
   },
 
   _handleMessageManager: function _handleMessageManager(aMessageManager) {
     if (this._enabled) {
       this._addMessageListeners(aMessageManager);
     }
     this._loadFrameScript(aMessageManager);
   },
 
   onEvent: function (event, data, callback) {
     switch (event) {
-      case 'Accessibility:Settings':
+      case "Accessibility:Settings":
         this._systemPref = data.enabled;
         this._enableOrDisable();
         break;
-      case 'Accessibility:NextObject':
-      case 'Accessibility:PreviousObject': {
+      case "Accessibility:NextObject":
+      case "Accessibility:PreviousObject": {
         let rule = data ?
           data.rule.substr(0, 1).toUpperCase() + data.rule.substr(1).toLowerCase() :
-          'Simple';
-        let method = event.replace(/Accessibility:(\w+)Object/, 'move$1');
-        this.Input.moveCursor(method, rule, 'gesture');
+          "Simple";
+        let method = event.replace(/Accessibility:(\w+)Object/, "move$1");
+        this.Input.moveCursor(method, rule, "gesture");
         break;
       }
-      case 'Accessibility:ActivateObject':
+      case "Accessibility:ActivateObject":
         this.Input.activateCurrent(data);
         break;
-      case 'Accessibility:LongPress':
+      case "Accessibility:LongPress":
         this.Input.sendContextMenuMessage();
         break;
-      case 'Accessibility:ScrollForward':
-        this.Input.androidScroll('forward');
+      case "Accessibility:ScrollForward":
+        this.Input.androidScroll("forward");
         break;
-      case 'Accessibility:ScrollBackward':
-        this.Input.androidScroll('backward');
+      case "Accessibility:ScrollBackward":
+        this.Input.androidScroll("backward");
         break;
-      case 'Accessibility:Focus':
+      case "Accessibility:Focus":
         this._focused = data.gainFocus;
         if (this._focused) {
           this.autoMove({ forcePresent: true, noOpIfOnScreen: true });
         }
         break;
-      case 'Accessibility:MoveByGranularity':
+      case "Accessibility:MoveByGranularity":
         this.Input.moveByGranularity(data);
         break;
     }
   },
 
   observe: function observe(aSubject, aTopic, aData) {
     switch (aTopic) {
-      case 'remote-browser-shown':
-      case 'inprocess-browser-shown':
+      case "remote-browser-shown":
+      case "inprocess-browser-shown":
       {
         // Ignore notifications that aren't from a Browser
         let frameLoader = aSubject.QueryInterface(Ci.nsIFrameLoader);
         if (!frameLoader.ownerIsMozBrowserFrame) {
           return;
         }
         this._handleMessageManager(frameLoader.messageManager);
         break;
       }
     }
   },
 
   _handleEvent: function _handleEvent(aEvent) {
     switch (aEvent.type) {
-      case 'TabOpen':
+      case "TabOpen":
       {
         let mm = Utils.getMessageManager(aEvent.target);
         this._handleMessageManager(mm);
         break;
       }
-      case 'TabClose':
+      case "TabClose":
       {
         let mm = Utils.getMessageManager(aEvent.target);
         let mmIndex = this._processedMessageManagers.indexOf(mm);
         if (mmIndex > -1) {
           this._removeMessageListeners(mm);
           this._processedMessageManagers.splice(mmIndex, 1);
         }
         break;
       }
-      case 'TabSelect':
+      case "TabSelect":
       {
         if (this._focused) {
           // We delay this for half a second so the awesomebar could close,
           // and we could use the current coordinates for the content item.
           // XXX TODO figure out how to avoid magic wait here.
           this.autoMove({
             delay: 500,
             forcePresent: true,
             noOpIfOnScreen: true,
-            moveMethod: 'moveFirst' });
+            moveMethod: "moveFirst" });
         }
         break;
       }
       default:
       {
         // A settings change, it does not have an event type
         if (aEvent.settingName == SCREENREADER_SETTING) {
           this._systemPref = aEvent.settingValue;
@@ -394,17 +394,17 @@ this.AccessFu = { // jshint ignore:line
         }
         break;
       }
     }
   },
 
   autoMove: function autoMove(aOptions) {
     let mm = Utils.getMessageManager(Utils.CurrentBrowser);
-    mm.sendAsyncMessage('AccessFu:AutoMove', aOptions);
+    mm.sendAsyncMessage("AccessFu:AutoMove", aOptions);
   },
 
   announce: function announce(aAnnouncement) {
     this._output(Presentation.announce(aAnnouncement), Utils.CurrentBrowser);
   },
 
   // So we don't enable/disable twice
   _enabled: false,
@@ -445,61 +445,61 @@ this.AccessFu = { // jshint ignore:line
       return bounds.expandToIntegers();
     }
 };
 
 var Output = {
   brailleState: {
     startOffset: 0,
     endOffset: 0,
-    text: '',
+    text: "",
     selectionStart: 0,
     selectionEnd: 0,
 
     init: function init(aOutput) {
-      if (aOutput && 'output' in aOutput) {
+      if (aOutput && "output" in aOutput) {
         this.startOffset = aOutput.startOffset;
         this.endOffset = aOutput.endOffset;
         // We need to append a space at the end so that the routing key
         // corresponding to the end of the output (i.e. the space) can be hit to
         // move the caret there.
-        this.text = aOutput.output + ' ';
-        this.selectionStart = typeof aOutput.selectionStart === 'number' ?
+        this.text = aOutput.output + " ";
+        this.selectionStart = typeof aOutput.selectionStart === "number" ?
                               aOutput.selectionStart : this.selectionStart;
-        this.selectionEnd = typeof aOutput.selectionEnd === 'number' ?
+        this.selectionEnd = typeof aOutput.selectionEnd === "number" ?
                             aOutput.selectionEnd : this.selectionEnd;
 
         return { text: this.text,
                  selectionStart: this.selectionStart,
                  selectionEnd: this.selectionEnd };
       }
 
       return null;
     },
 
     adjustText: function adjustText(aText) {
       let newBraille = [];
       let braille = {};
 
       let prefix = this.text.substring(0, this.startOffset).trim();
       if (prefix) {
-        prefix += ' ';
+        prefix += " ";
         newBraille.push(prefix);
       }
 
       newBraille.push(aText);
 
       let suffix = this.text.substring(this.endOffset).trim();
       if (suffix) {
-        suffix = ' ' + suffix;
+        suffix = " " + suffix;
         newBraille.push(suffix);
       }
 
       this.startOffset = braille.startOffset = prefix.length;
-      this.text = braille.text = newBraille.join('') + ' ';
+      this.text = braille.text = newBraille.join("") + " ";
       this.endOffset = braille.endOffset = braille.text.length - suffix.length;
       braille.selectionStart = this.selectionStart;
       braille.selectionEnd = this.selectionEnd;
 
       return braille;
     },
 
     adjustSelection: function adjustSelection(aSelection) {
@@ -513,87 +513,87 @@ var Output = {
       this.selectionEnd = braille.selectionEnd =
         aSelection.selectionEnd + this.startOffset;
 
       return braille;
     }
   },
 
   start: function start() {
-    Cu.import('resource://gre/modules/Geometry.jsm');
+    Cu.import("resource://gre/modules/Geometry.jsm");
   },
 
   stop: function stop() {
     if (this.highlightBox) {
       let highlightBox = this.highlightBox.get();
       if (highlightBox) {
         highlightBox.remove();
       }
       delete this.highlightBox;
     }
   },
 
   B2G: function B2G(aDetails) {
-    Utils.dispatchChromeEvent('accessibility-output', aDetails);
+    Utils.dispatchChromeEvent("accessibility-output", aDetails);
   },
 
   Visual: function Visual(aDetail, aBrowser) {
     switch (aDetail.eventType) {
-      case 'viewport-change':
-      case 'vc-change':
+      case "viewport-change":
+      case "vc-change":
       {
         let highlightBox = null;
         if (!this.highlightBox) {
           let doc = Utils.win.document;
           // Add highlight box
           highlightBox = Utils.win.document.
-            createElementNS('http://www.w3.org/1999/xhtml', 'div');
+            createElementNS("http://www.w3.org/1999/xhtml", "div");
           let parent = doc.body || doc.documentElement;
           parent.appendChild(highlightBox);
-          highlightBox.id = 'virtual-cursor-box';
+          highlightBox.id = "virtual-cursor-box";
 
           // Add highlight inset for inner shadow
           highlightBox.appendChild(
-            doc.createElementNS('http://www.w3.org/1999/xhtml', 'div'));
+            doc.createElementNS("http://www.w3.org/1999/xhtml", "div"));
 
           this.highlightBox = Cu.getWeakReference(highlightBox);
         } else {
           highlightBox = this.highlightBox.get();
         }
 
         let padding = aDetail.padding;
         let r = AccessFu.adjustContentBounds(aDetail.bounds, aBrowser, true);
 
         // First hide it to avoid flickering when changing the style.
-        highlightBox.classList.remove('show');
-        highlightBox.style.top = (r.top - padding) + 'px';
-        highlightBox.style.left = (r.left - padding) + 'px';
-        highlightBox.style.width = (r.width + padding*2) + 'px';
-        highlightBox.style.height = (r.height + padding*2) + 'px';
-        highlightBox.classList.add('show');
+        highlightBox.classList.remove("show");
+        highlightBox.style.top = (r.top - padding) + "px";
+        highlightBox.style.left = (r.left - padding) + "px";
+        highlightBox.style.width = (r.width + padding*2) + "px";
+        highlightBox.style.height = (r.height + padding*2) + "px";
+        highlightBox.classList.add("show");
 
         break;
       }
-      case 'tabstate-change':
+      case "tabstate-change":
       {
         let highlightBox = this.highlightBox ? this.highlightBox.get() : null;
         if (highlightBox) {
-          highlightBox.classList.remove('show');
+          highlightBox.classList.remove("show");
         }
         break;
       }
     }
   },
 
   Android: function Android(aDetails, aBrowser) {
     const ANDROID_VIEW_TEXT_CHANGED = 0x10;
     const ANDROID_VIEW_TEXT_SELECTION_CHANGED = 0x2000;
 
     for (let androidEvent of aDetails) {
-      androidEvent.type = 'Accessibility:Event';
+      androidEvent.type = "Accessibility:Event";
       if (androidEvent.bounds) {
         androidEvent.bounds = AccessFu.adjustContentBounds(
           androidEvent.bounds, aBrowser);
       }
 
       switch (androidEvent.eventType) {
         case ANDROID_VIEW_TEXT_CHANGED:
           androidEvent.brailleOutput = this.brailleState.adjustText(
@@ -609,140 +609,140 @@ var Output = {
           break;
       }
 
       Utils.win.WindowEventDispatcher.sendRequest(androidEvent);
     }
   },
 
   Braille: function Braille(aDetails) {
-    Logger.debug('Braille output: ' + aDetails.output);
+    Logger.debug("Braille output: " + aDetails.output);
   }
 };
 
 var Input = {
   editState: {},
 
   start: function start() {
     // XXX: This is too disruptive on desktop for now.
     // Might need to add special modifiers.
-    if (Utils.MozBuildApp != 'browser') {
-      Utils.win.document.addEventListener('keypress', this, true);
+    if (Utils.MozBuildApp != "browser") {
+      Utils.win.document.addEventListener("keypress", this, true);
     }
-    Utils.win.addEventListener('mozAccessFuGesture', this, true);
+    Utils.win.addEventListener("mozAccessFuGesture", this, true);
   },
 
   stop: function stop() {
-    if (Utils.MozBuildApp != 'browser') {
-      Utils.win.document.removeEventListener('keypress', this, true);
+    if (Utils.MozBuildApp != "browser") {
+      Utils.win.document.removeEventListener("keypress", this, true);
     }
-    Utils.win.removeEventListener('mozAccessFuGesture', this, true);
+    Utils.win.removeEventListener("mozAccessFuGesture", this, true);
   },
 
   handleEvent: function Input_handleEvent(aEvent) {
     try {
       switch (aEvent.type) {
-      case 'keypress':
+      case "keypress":
         this._handleKeypress(aEvent);
         break;
-      case 'mozAccessFuGesture':
+      case "mozAccessFuGesture":
         this._handleGesture(aEvent.detail);
         break;
       }
     } catch (x) {
       Logger.logException(x);
     }
   },
 
   _handleGesture: function _handleGesture(aGesture) {
     let gestureName = aGesture.type + aGesture.touches.length;
-    Logger.debug('Gesture', aGesture.type,
-                 '(fingers: ' + aGesture.touches.length + ')');
+    Logger.debug("Gesture", aGesture.type,
+                 "(fingers: " + aGesture.touches.length + ")");
 
     switch (gestureName) {
-      case 'dwell1':
-      case 'explore1':
-        this.moveToPoint('Simple', aGesture.touches[0].x,
+      case "dwell1":
+      case "explore1":
+        this.moveToPoint("Simple", aGesture.touches[0].x,
           aGesture.touches[0].y);
         break;
-      case 'doubletap1':
+      case "doubletap1":
         this.activateCurrent();
         break;
-      case 'doubletaphold1':
-        Utils.dispatchChromeEvent('accessibility-control', 'quicknav-menu');
+      case "doubletaphold1":
+        Utils.dispatchChromeEvent("accessibility-control", "quicknav-menu");
         break;
-      case 'swiperight1':
-        this.moveCursor('moveNext', 'Simple', 'gestures');
+      case "swiperight1":
+        this.moveCursor("moveNext", "Simple", "gestures");
         break;
-      case 'swipeleft1':
-        this.moveCursor('movePrevious', 'Simple', 'gesture');
+      case "swipeleft1":
+        this.moveCursor("movePrevious", "Simple", "gesture");
         break;
-      case 'swipeup1':
+      case "swipeup1":
         this.moveCursor(
-          'movePrevious', this.quickNavMode.current, 'gesture', true);
+          "movePrevious", this.quickNavMode.current, "gesture", true);
         break;
-      case 'swipedown1':
-        this.moveCursor('moveNext', this.quickNavMode.current, 'gesture', true);
+      case "swipedown1":
+        this.moveCursor("moveNext", this.quickNavMode.current, "gesture", true);
         break;
-      case 'exploreend1':
-      case 'dwellend1':
+      case "exploreend1":
+      case "dwellend1":
         this.activateCurrent(null, true);
         break;
-      case 'swiperight2':
+      case "swiperight2":
         if (aGesture.edge) {
-          Utils.dispatchChromeEvent('accessibility-control',
-            'edge-swipe-right');
+          Utils.dispatchChromeEvent("accessibility-control",
+            "edge-swipe-right");
           break;
         }
         this.sendScrollMessage(-1, true);
         break;
-      case 'swipedown2':
+      case "swipedown2":
         if (aGesture.edge) {
-          Utils.dispatchChromeEvent('accessibility-control', 'edge-swipe-down');
+          Utils.dispatchChromeEvent("accessibility-control", "edge-swipe-down");
           break;
         }
         this.sendScrollMessage(-1);
         break;
-      case 'swipeleft2':
+      case "swipeleft2":
         if (aGesture.edge) {
-          Utils.dispatchChromeEvent('accessibility-control', 'edge-swipe-left');
+          Utils.dispatchChromeEvent("accessibility-control", "edge-swipe-left");
           break;
         }
         this.sendScrollMessage(1, true);
         break;
-      case 'swipeup2':
+      case "swipeup2":
         if (aGesture.edge) {
-          Utils.dispatchChromeEvent('accessibility-control', 'edge-swipe-up');
+          Utils.dispatchChromeEvent("accessibility-control", "edge-swipe-up");
           break;
         }
         this.sendScrollMessage(1);
         break;
-      case 'explore2':
+      case "explore2":
         Utils.CurrentBrowser.contentWindow.scrollBy(
           -aGesture.deltaX, -aGesture.deltaY);
         break;
-      case 'swiperight3':
-        this.moveCursor('moveNext', this.quickNavMode.current, 'gesture');
+      case "swiperight3":
+        this.moveCursor("moveNext", this.quickNavMode.current, "gesture");
         break;
-      case 'swipeleft3':
-        this.moveCursor('movePrevious', this.quickNavMode.current, 'gesture');
+      case "swipeleft3":
+        this.moveCursor("movePrevious", this.quickNavMode.current, "gesture");
         break;
-      case 'swipedown3':
+      case "swipedown3":
         this.quickNavMode.next();
-        AccessFu.announce('quicknav_' + this.quickNavMode.current);
+        AccessFu.announce("quicknav_" + this.quickNavMode.current);
         break;
-      case 'swipeup3':
+      case "swipeup3":
         this.quickNavMode.previous();
-        AccessFu.announce('quicknav_' + this.quickNavMode.current);
+        AccessFu.announce("quicknav_" + this.quickNavMode.current);
         break;
-      case 'tripletap3':
-        Utils.dispatchChromeEvent('accessibility-control', 'toggle-shade');
+      case "tripletap3":
+        Utils.dispatchChromeEvent("accessibility-control", "toggle-shade");
         break;
-      case 'tap2':
-        Utils.dispatchChromeEvent('accessibility-control', 'toggle-pause');
+      case "tap2":
+        Utils.dispatchChromeEvent("accessibility-control", "toggle-pause");
         break;
     }
   },
 
   _handleKeypress: function _handleKeypress(aEvent) {
     let target = aEvent.target;
 
     // Ignore keys with modifiers so the content could take advantage of them.
@@ -757,60 +757,60 @@ var Input = {
         // If it was pressed with meta, pass the key on without the meta.
         if (this.editState.editing) {
           return;
         }
 
         let key = String.fromCharCode(aEvent.charCode);
         try {
           let [methodName, rule] = this.keyMap[key];
-          this.moveCursor(methodName, rule, 'keyboard');
+          this.moveCursor(methodName, rule, "keyboard");
         } catch (x) {
           return;
         }
         break;
       case aEvent.DOM_VK_RIGHT:
         if (this.editState.editing) {
           if (!this.editState.atEnd) {
             // Don't move forward if caret is not at end of entry.
             // XXX: Fix for rtl
             return;
           } else {
             target.blur();
           }
         }
         this.moveCursor(aEvent.shiftKey ?
-          'moveLast' : 'moveNext', 'Simple', 'keyboard');
+          "moveLast" : "moveNext", "Simple", "keyboard");
         break;
       case aEvent.DOM_VK_LEFT:
         if (this.editState.editing) {
           if (!this.editState.atStart) {
             // Don't move backward if caret is not at start of entry.
             // XXX: Fix for rtl
             return;
           } else {
             target.blur();
           }
         }
         this.moveCursor(aEvent.shiftKey ?
-          'moveFirst' : 'movePrevious', 'Simple', 'keyboard');
+          "moveFirst" : "movePrevious", "Simple", "keyboard");
         break;
       case aEvent.DOM_VK_UP:
         if (this.editState.multiline) {
           if (!this.editState.atStart) {
             // Don't blur content if caret is not at start of text area.
             return;
           } else {
             target.blur();
           }
         }
 
-        if (Utils.MozBuildApp == 'mobile/android') {
+        if (Utils.MozBuildApp == "mobile/android") {
           // Return focus to native Android browser chrome.
-          Utils.win.WindowEventDispatcher.dispatch('ToggleChrome:Focus');
+          Utils.win.WindowEventDispatcher.dispatch("ToggleChrome:Focus");
         }
         break;
       case aEvent.DOM_VK_RETURN:
         if (this.editState.editing) {
           return;
         }
         this.activateCurrent();
         break;
@@ -821,137 +821,137 @@ var Input = {
     aEvent.preventDefault();
     aEvent.stopPropagation();
   },
 
   moveToPoint: function moveToPoint(aRule, aX, aY) {
     // XXX: Bug 1013408 - There is no alignment between the chrome window's
     // viewport size and the content viewport size in Android. This makes
     // sending mouse events beyond its bounds impossible.
-    if (Utils.MozBuildApp === 'mobile/android') {
+    if (Utils.MozBuildApp === "mobile/android") {
       let mm = Utils.getMessageManager(Utils.CurrentBrowser);
-      mm.sendAsyncMessage('AccessFu:MoveToPoint',
-        {rule: aRule, x: aX, y: aY, origin: 'top'});
+      mm.sendAsyncMessage("AccessFu:MoveToPoint",
+        {rule: aRule, x: aX, y: aY, origin: "top"});
     } else {
       let win = Utils.win;
-      Utils.winUtils.sendMouseEvent('mousemove',
+      Utils.winUtils.sendMouseEvent("mousemove",
         aX - win.mozInnerScreenX, aY - win.mozInnerScreenY, 0, 0, 0);
     }
   },
 
   moveCursor: function moveCursor(aAction, aRule, aInputType, aAdjustRange) {
     let mm = Utils.getMessageManager(Utils.CurrentBrowser);
-    mm.sendAsyncMessage('AccessFu:MoveCursor',
+    mm.sendAsyncMessage("AccessFu:MoveCursor",
                         { action: aAction, rule: aRule,
-                          origin: 'top', inputType: aInputType,
+                          origin: "top", inputType: aInputType,
                           adjustRange: aAdjustRange });
   },
 
   androidScroll: function androidScroll(aDirection) {
     let mm = Utils.getMessageManager(Utils.CurrentBrowser);
-    mm.sendAsyncMessage('AccessFu:AndroidScroll',
-                        { direction: aDirection, origin: 'top' });
+    mm.sendAsyncMessage("AccessFu:AndroidScroll",
+                        { direction: aDirection, origin: "top" });
   },
 
   moveByGranularity: function moveByGranularity(aDetails) {
     const GRANULARITY_PARAGRAPH = 8;
     const GRANULARITY_LINE = 4;
 
     if (!this.editState.editing) {
       if (aDetails.granularity & (GRANULARITY_PARAGRAPH | GRANULARITY_LINE)) {
-        this.moveCursor('move' + aDetails.direction, 'Simple', 'gesture');
+        this.moveCursor("move" + aDetails.direction, "Simple", "gesture");
         return;
       }
     } else {
       aDetails.atStart = this.editState.atStart;
       aDetails.atEnd = this.editState.atEnd;
     }
 
     let mm = Utils.getMessageManager(Utils.CurrentBrowser);
-    let type = this.editState.editing ? 'AccessFu:MoveCaret' :
-                                        'AccessFu:MoveByGranularity';
+    let type = this.editState.editing ? "AccessFu:MoveCaret" :
+                                        "AccessFu:MoveByGranularity";
     mm.sendAsyncMessage(type, aDetails);
   },
 
   activateCurrent: function activateCurrent(aData, aActivateIfKey = false) {
     let mm = Utils.getMessageManager(Utils.CurrentBrowser);
-    let offset = aData && typeof aData.keyIndex === 'number' ?
+    let offset = aData && typeof aData.keyIndex === "number" ?
                  aData.keyIndex - Output.brailleState.startOffset : -1;
 
-    mm.sendAsyncMessage('AccessFu:Activate',
+    mm.sendAsyncMessage("AccessFu:Activate",
                         {offset: offset, activateIfKey: aActivateIfKey});
   },
 
   sendContextMenuMessage: function sendContextMenuMessage() {
     let mm = Utils.getMessageManager(Utils.CurrentBrowser);
-    mm.sendAsyncMessage('AccessFu:ContextMenu', {});
+    mm.sendAsyncMessage("AccessFu:ContextMenu", {});
   },
 
   setEditState: function setEditState(aEditState) {
-    Logger.debug(() => { return ['setEditState', JSON.stringify(aEditState)] });
+    Logger.debug(() => { return ["setEditState", JSON.stringify(aEditState)] });
     this.editState = aEditState;
   },
 
   // XXX: This is here for backwards compatability with screen reader simulator
   // it should be removed when the extension is updated on amo.
   scroll: function scroll(aPage, aHorizontal) {
     this.sendScrollMessage(aPage, aHorizontal);
   },
 
   sendScrollMessage: function sendScrollMessage(aPage, aHorizontal) {
     let mm = Utils.getMessageManager(Utils.CurrentBrowser);
-    mm.sendAsyncMessage('AccessFu:Scroll',
-      {page: aPage, horizontal: aHorizontal, origin: 'top'});
+    mm.sendAsyncMessage("AccessFu:Scroll",
+      {page: aPage, horizontal: aHorizontal, origin: "top"});
   },
 
   doScroll: function doScroll(aDetails) {
     let horizontal = aDetails.horizontal;
     let page = aDetails.page;
     let p = AccessFu.adjustContentBounds(
       aDetails.bounds, Utils.CurrentBrowser, true).center();
     Utils.winUtils.sendWheelEvent(p.x, p.y,
       horizontal ? page : 0, horizontal ? 0 : page, 0,
       Utils.win.WheelEvent.DOM_DELTA_PAGE, 0, 0, 0, 0);
   },
 
   get keyMap() {
     delete this.keyMap;
     this.keyMap = {
-      a: ['moveNext', 'Anchor'],
-      A: ['movePrevious', 'Anchor'],
-      b: ['moveNext', 'Button'],
-      B: ['movePrevious', 'Button'],
-      c: ['moveNext', 'Combobox'],
-      C: ['movePrevious', 'Combobox'],
-      d: ['moveNext', 'Landmark'],
-      D: ['movePrevious', 'Landmark'],
-      e: ['moveNext', 'Entry'],
-      E: ['movePrevious', 'Entry'],
-      f: ['moveNext', 'FormElement'],
-      F: ['movePrevious', 'FormElement'],
-      g: ['moveNext', 'Graphic'],
-      G: ['movePrevious', 'Graphic'],
-      h: ['moveNext', 'Heading'],
-      H: ['movePrevious', 'Heading'],
-      i: ['moveNext', 'ListItem'],
-      I: ['movePrevious', 'ListItem'],
-      k: ['moveNext', 'Link'],
-      K: ['movePrevious', 'Link'],
-      l: ['moveNext', 'List'],
-      L: ['movePrevious', 'List'],
-      p: ['moveNext', 'PageTab'],
-      P: ['movePrevious', 'PageTab'],
-      r: ['moveNext', 'RadioButton'],
-      R: ['movePrevious', 'RadioButton'],
-      s: ['moveNext', 'Separator'],
-      S: ['movePrevious', 'Separator'],
-      t: ['moveNext', 'Table'],
-      T: ['movePrevious', 'Table'],
-      x: ['moveNext', 'Checkbox'],
-      X: ['movePrevious', 'Checkbox']
+      a: ["moveNext", "Anchor"],
+      A: ["movePrevious", "Anchor"],
+      b: ["moveNext", "Button"],
+      B: ["movePrevious", "Button"],
+      c: ["moveNext", "Combobox"],
+      C: ["movePrevious", "Combobox"],
+      d: ["moveNext", "Landmark"],
+      D: ["movePrevious", "Landmark"],
+      e: ["moveNext", "Entry"],
+      E: ["movePrevious", "Entry"],
+      f: ["moveNext", "FormElement"],
+      F: ["movePrevious", "FormElement"],
+      g: ["moveNext", "Graphic"],
+      G: ["movePrevious", "Graphic"],
+      h: ["moveNext", "Heading"],
+      H: ["movePrevious", "Heading"],
+      i: ["moveNext", "ListItem"],
+      I: ["movePrevious", "ListItem"],
+      k: ["moveNext", "Link"],
+      K: ["movePrevious", "Link"],
+      l: ["moveNext", "List"],
+      L: ["movePrevious", "List"],
+      p: ["moveNext", "PageTab"],
+      P: ["movePrevious", "PageTab"],
+      r: ["moveNext", "RadioButton"],
+      R: ["movePrevious", "RadioButton"],
+      s: ["moveNext", "Separator"],
+      S: ["movePrevious", "Separator"],
+      t: ["moveNext", "Table"],
+      T: ["movePrevious", "Table"],
+      x: ["moveNext", "Checkbox"],
+      X: ["movePrevious", "Checkbox"]
     };
 
     return this.keyMap;
   },
 
   quickNavMode: {
     get current() {
       return this.modes[this._currentIndex];
@@ -966,21 +966,21 @@ var Input = {
     next: function quickNavMode_next() {
       Services.prefs.setIntPref(QUICKNAV_INDEX_PREF,
         this._currentIndex + 1 >= this.modes.length ?
           0 : this._currentIndex + 1);
     },
 
     updateModes: function updateModes(aModes) {
       if (aModes) {
-        this.modes = aModes.split(',');
+        this.modes = aModes.split(",");
       } else {
         this.modes = [];
       }
     },
 
     updateCurrentMode: function updateCurrentMode(aModeIndex) {
-      Logger.debug('Quicknav mode:', this.modes[aModeIndex]);
+      Logger.debug("Quicknav mode:", this.modes[aModeIndex]);
       this._currentIndex = aModeIndex;
     }
   }
 };
 AccessFu.Input = Input;
--- a/accessible/jsat/Constants.jsm
+++ b/accessible/jsat/Constants.jsm
@@ -1,59 +1,59 @@
 const Ci = Components.interfaces;
 const Cu = Components.utils;
 
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 
-this.EXPORTED_SYMBOLS = ['Roles', 'Events', 'Relations',
-                         'Filters', 'States', 'Prefilters'];
+this.EXPORTED_SYMBOLS = ["Roles", "Events", "Relations",
+                         "Filters", "States", "Prefilters"];
 
 function ConstantsMap (aObject, aPrefix, aMap = {}, aModifier = null) {
   let offset = aPrefix.length;
   for (var name in aObject) {
     if (name.indexOf(aPrefix) === 0) {
       aMap[name.slice(offset)] = aModifier ?
         aModifier(aObject[name]) : aObject[name];
     }
   }
 
   return aMap;
 }
 
 XPCOMUtils.defineLazyGetter(
-  this, 'Roles',
+  this, "Roles",
   function() {
-    return ConstantsMap(Ci.nsIAccessibleRole, 'ROLE_');
+    return ConstantsMap(Ci.nsIAccessibleRole, "ROLE_");
   });
 
 XPCOMUtils.defineLazyGetter(
-  this, 'Events',
+  this, "Events",
   function() {
-    return ConstantsMap(Ci.nsIAccessibleEvent, 'EVENT_');
+    return ConstantsMap(Ci.nsIAccessibleEvent, "EVENT_");
   });
 
 XPCOMUtils.defineLazyGetter(
-  this, 'Relations',
+  this, "Relations",
   function() {
-    return ConstantsMap(Ci.nsIAccessibleRelation, 'RELATION_');
+    return ConstantsMap(Ci.nsIAccessibleRelation, "RELATION_");
   });
 
 XPCOMUtils.defineLazyGetter(
-  this, 'Prefilters',
+  this, "Prefilters",
   function() {
-    return ConstantsMap(Ci.nsIAccessibleTraversalRule, 'PREFILTER_');
+    return ConstantsMap(Ci.nsIAccessibleTraversalRule, "PREFILTER_");
   });
 
 XPCOMUtils.defineLazyGetter(
-  this, 'Filters',
+  this, "Filters",
   function() {
-    return ConstantsMap(Ci.nsIAccessibleTraversalRule, 'FILTER_');
+    return ConstantsMap(Ci.nsIAccessibleTraversalRule, "FILTER_");
   });
 
 XPCOMUtils.defineLazyGetter(
-  this, 'States',
+  this, "States",
   function() {
-    let statesMap = ConstantsMap(Ci.nsIAccessibleStates, 'STATE_', {},
+    let statesMap = ConstantsMap(Ci.nsIAccessibleStates, "STATE_", {},
                                  (val) => { return { base: val, extended: 0 }; });
-    ConstantsMap(Ci.nsIAccessibleStates, 'EXT_STATE_', statesMap,
+    ConstantsMap(Ci.nsIAccessibleStates, "EXT_STATE_", statesMap,
                  (val) => { return { base: 0, extended: val }; });
     return statesMap;
   });
--- a/accessible/jsat/ContentControl.jsm
+++ b/accessible/jsat/ContentControl.jsm
@@ -1,175 +1,175 @@
 /* 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/. */
 
 var Ci = Components.interfaces;
 var Cu = Components.utils;
 
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
-XPCOMUtils.defineLazyModuleGetter(this, 'Services',
-  'resource://gre/modules/Services.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Utils',
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Logger',
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Roles',
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'TraversalRules',
-  'resource://gre/modules/accessibility/Traversal.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'TraversalHelper',
-  'resource://gre/modules/accessibility/Traversal.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Presentation',
-  'resource://gre/modules/accessibility/Presentation.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, "Services",
+  "resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Utils",
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Logger",
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Roles",
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "TraversalRules",
+  "resource://gre/modules/accessibility/Traversal.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "TraversalHelper",
+  "resource://gre/modules/accessibility/Traversal.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Presentation",
+  "resource://gre/modules/accessibility/Presentation.jsm");
 
-this.EXPORTED_SYMBOLS = ['ContentControl'];
+this.EXPORTED_SYMBOLS = ["ContentControl"];
 
 const MOVEMENT_GRANULARITY_CHARACTER = 1;
 const MOVEMENT_GRANULARITY_WORD = 2;
 const MOVEMENT_GRANULARITY_PARAGRAPH = 8;
 
 this.ContentControl = function ContentControl(aContentScope) {
   this._contentScope = Cu.getWeakReference(aContentScope);
   this._childMessageSenders = new WeakMap();
 };
 
 this.ContentControl.prototype = {
-  messagesOfInterest: ['AccessFu:MoveCursor',
-                       'AccessFu:ClearCursor',
-                       'AccessFu:MoveToPoint',
-                       'AccessFu:AutoMove',
-                       'AccessFu:Activate',
-                       'AccessFu:MoveCaret',
-                       'AccessFu:MoveByGranularity',
-                       'AccessFu:AndroidScroll'],
+  messagesOfInterest: ["AccessFu:MoveCursor",
+                       "AccessFu:ClearCursor",
+                       "AccessFu:MoveToPoint",
+                       "AccessFu:AutoMove",
+                       "AccessFu:Activate",
+                       "AccessFu:MoveCaret",
+                       "AccessFu:MoveByGranularity",
+                       "AccessFu:AndroidScroll"],
 
   start: function cc_start() {
     let cs = this._contentScope.get();
     for (let message of this.messagesOfInterest) {
       cs.addMessageListener(message, this);
     }
-    cs.addEventListener('mousemove', this);
+    cs.addEventListener("mousemove", this);
   },
 
   stop: function cc_stop() {
     let cs = this._contentScope.get();
     for (let message of this.messagesOfInterest) {
       cs.removeMessageListener(message, this);
     }
-    cs.removeEventListener('mousemove', this);
+    cs.removeEventListener("mousemove", this);
   },
 
   get document() {
     return this._contentScope.get().content.document;
   },
 
   get window() {
     return this._contentScope.get().content;
   },
 
   get vc() {
     return Utils.getVirtualCursor(this.document);
   },
 
   receiveMessage: function cc_receiveMessage(aMessage) {
     Logger.debug(() => {
-      return ['ContentControl.receiveMessage',
+      return ["ContentControl.receiveMessage",
         aMessage.name,
         JSON.stringify(aMessage.json)];
     });
 
     // If we get an explicit message, we should immediately cancel any autoMove
     this.cancelAutoMove();
 
     try {
-      let func = this['handle' + aMessage.name.slice(9)]; // 'AccessFu:'.length
+      let func = this["handle" + aMessage.name.slice(9)]; // 'AccessFu:'.length
       if (func) {
         func.bind(this)(aMessage);
       } else {
-        Logger.warning('ContentControl: Unhandled message:', aMessage.name);
+        Logger.warning("ContentControl: Unhandled message:", aMessage.name);
       }
     } catch (x) {
       Logger.logException(
-        x, 'Error handling message: ' + JSON.stringify(aMessage.json));
+        x, "Error handling message: " + JSON.stringify(aMessage.json));
     }
   },
 
   handleAndroidScroll: function cc_handleAndroidScroll(aMessage) {
     let vc = this.vc;
     let position = vc.position;
 
-    if (aMessage.json.origin != 'child' && this.sendToChild(vc, aMessage)) {
+    if (aMessage.json.origin != "child" && this.sendToChild(vc, aMessage)) {
       // Forwarded succesfully to child cursor.
       return;
     }
 
     // Counter-intuitive, but scrolling backward (ie. up), actually should
     // increase range values.
-    if (this.adjustRange(position, aMessage.json.direction === 'backward')) {
+    if (this.adjustRange(position, aMessage.json.direction === "backward")) {
       return;
     }
 
-    this._contentScope.get().sendAsyncMessage('AccessFu:DoScroll',
+    this._contentScope.get().sendAsyncMessage("AccessFu:DoScroll",
       { bounds: Utils.getBounds(position, true),
-        page: aMessage.json.direction === 'forward' ? 1 : -1,
+        page: aMessage.json.direction === "forward" ? 1 : -1,
         horizontal: false });
   },
 
   handleMoveCursor: function cc_handleMoveCursor(aMessage) {
     let origin = aMessage.json.origin;
     let action = aMessage.json.action;
     let adjustRange = aMessage.json.adjustRange;
     let vc = this.vc;
 
-    if (origin != 'child' && this.sendToChild(vc, aMessage)) {
+    if (origin != "child" && this.sendToChild(vc, aMessage)) {
       // Forwarded succesfully to child cursor.
       return;
     }
 
-    if (adjustRange && this.adjustRange(vc.position, action === 'moveNext')) {
+    if (adjustRange && this.adjustRange(vc.position, action === "moveNext")) {
       return;
     }
 
     let moved = TraversalHelper.move(vc, action, aMessage.json.rule);
 
     if (moved) {
-      if (origin === 'child') {
+      if (origin === "child") {
         // We just stepped out of a child, clear child cursor.
         Utils.getMessageManager(aMessage.target).sendAsyncMessage(
-          'AccessFu:ClearCursor', {});
+          "AccessFu:ClearCursor", {});
       } else {
         // We potentially landed on a new child cursor. If so, we want to
         // either be on the first or last item in the child doc.
         let childAction = action;
-        if (action === 'moveNext') {
-          childAction = 'moveFirst';
-        } else if (action === 'movePrevious') {
-          childAction = 'moveLast';
+        if (action === "moveNext") {
+          childAction = "moveFirst";
+        } else if (action === "movePrevious") {
+          childAction = "moveLast";
         }
 
         // Attempt to forward move to a potential child cursor in our
         // new position.
         this.sendToChild(vc, aMessage, { action: childAction }, true);
       }
     } else if (!this._childMessageSenders.has(aMessage.target) &&
-               origin !== 'top') {
+               origin !== "top") {
       // We failed to move, and the message is not from a parent, so forward
       // to it.
       this.sendToParent(aMessage);
     } else {
-      this._contentScope.get().sendAsyncMessage('AccessFu:Present',
+      this._contentScope.get().sendAsyncMessage("AccessFu:Present",
         Presentation.noMove(action));
     }
   },
 
   handleEvent: function cc_handleEvent(aEvent) {
-    if (aEvent.type === 'mousemove') {
+    if (aEvent.type === "mousemove") {
       this.handleMoveToPoint(
-        { json: { x: aEvent.screenX, y: aEvent.screenY, rule: 'Simple' } });
+        { json: { x: aEvent.screenX, y: aEvent.screenY, rule: "Simple" } });
     }
     if (!Utils.getMessageManager(aEvent.target)) {
       aEvent.preventDefault();
     } else {
       aEvent.target.focus();
     }
   },
 
@@ -180,29 +180,29 @@ this.ContentControl.prototype = {
     let dpr = this.window.devicePixelRatio;
     this.vc.moveToPoint(rule, x * dpr, y * dpr, true);
   },
 
   handleClearCursor: function cc_handleClearCursor(aMessage) {
     let forwarded = this.sendToChild(this.vc, aMessage);
     this.vc.position = null;
     if (!forwarded) {
-      this._contentScope.get().sendAsyncMessage('AccessFu:CursorCleared');
+      this._contentScope.get().sendAsyncMessage("AccessFu:CursorCleared");
     }
     this.document.activeElement.blur();
   },
 
   handleAutoMove: function cc_handleAutoMove(aMessage) {
     this.autoMove(null, aMessage.json);
   },
 
   handleActivate: function cc_handleActivate(aMessage) {
     let activateAccessible = (aAccessible) => {
       Logger.debug(() => {
-        return ['activateAccessible', Logger.accessibleToString(aAccessible)];
+        return ["activateAccessible", Logger.accessibleToString(aAccessible)];
       });
       try {
         if (aMessage.json.activateIfKey &&
           !Utils.isActivatableOnFingerUp(aAccessible)) {
           // Only activate keys, don't do anything on other objects.
           return;
         }
       } catch (e) {
@@ -229,28 +229,28 @@ this.ContentControl.prototype = {
         let objX = {}, objY = {}, objW = {}, objH = {};
         aAccessible.getBounds(objX, objY, objW, objH);
 
         let x = Math.round((objX.value - docX.value) + objW.value / 2);
         let y = Math.round((objY.value - docY.value) + objH.value / 2);
 
         let node = aAccessible.DOMNode || aAccessible.parent.DOMNode;
 
-        for (let eventType of ['mousedown', 'mouseup']) {
-          let evt = this.document.createEvent('MouseEvents');
+        for (let eventType of ["mousedown", "mouseup"]) {
+          let evt = this.document.createEvent("MouseEvents");
           evt.initMouseEvent(eventType, true, true, this.window,
             x, y, 0, 0, 0, false, false, false, false, 0, null);
           node.dispatchEvent(evt);
         }
       }
 
       if (!Utils.isActivatableOnFingerUp(aAccessible)) {
         // Keys will typically have a sound of their own.
-        this._contentScope.get().sendAsyncMessage('AccessFu:Present',
-          Presentation.actionInvoked(aAccessible, 'click'));
+        this._contentScope.get().sendAsyncMessage("AccessFu:Present",
+          Presentation.actionInvoked(aAccessible, "click"));
       }
     };
 
     let focusedAcc = Utils.AccService.getAccessibleFor(
       this.document.activeElement);
     if (focusedAcc && this.vc.position === focusedAcc
         && focusedAcc.role === Roles.ENTRY) {
       let accText = focusedAcc.QueryInterface(Ci.nsIAccessibleText);
@@ -298,23 +298,23 @@ this.ContentControl.prototype = {
       return false;
     }
 
     let elem = acc.DOMNode;
     if (!elem) {
       return false;
     }
 
-    if (elem.tagName === 'INPUT' && elem.type === 'range') {
-      elem[aStepUp ? 'stepDown' : 'stepUp']();
-      let evt = this.document.createEvent('UIEvent');
-      evt.initEvent('change', true, true);
+    if (elem.tagName === "INPUT" && elem.type === "range") {
+      elem[aStepUp ? "stepDown" : "stepUp"]();
+      let evt = this.document.createEvent("UIEvent");
+      evt.initEvent("change", true, true);
       elem.dispatchEvent(evt);
     } else {
-      let evt = this.document.createEvent('KeyboardEvent');
+      let evt = this.document.createEvent("KeyboardEvent");
       let keycode = aStepUp ? evt.DOM_VK_DOWN : evt.DOM_VK_UP;
       evt.initKeyEvent(
         "keypress", false, true, null, false, false, false, false, keycode, 0);
       elem.dispatchEvent(evt);
     }
 
     return true;
   },
@@ -330,84 +330,84 @@ this.ContentControl.prototype = {
         break;
       case MOVEMENT_GRANULARITY_WORD:
         granularity = Ci.nsIAccessiblePivot.WORD_BOUNDARY;
         break;
       default:
         return;
     }
 
-    if (direction === 'Previous') {
+    if (direction === "Previous") {
       this.vc.movePreviousByText(granularity);
-    } else if (direction === 'Next') {
+    } else if (direction === "Next") {
       this.vc.moveNextByText(granularity);
     }
   },
 
   presentCaretChange: function cc_presentCaretChange(
     aText, aOldOffset, aNewOffset) {
     if (aOldOffset !== aNewOffset) {
       let msg = Presentation.textSelectionChanged(aText, aNewOffset, aNewOffset,
         aOldOffset, aOldOffset, true);
-      this._contentScope.get().sendAsyncMessage('AccessFu:Present', msg);
+      this._contentScope.get().sendAsyncMessage("AccessFu:Present", msg);
     }
   },
 
   handleMoveCaret: function cc_handleMoveCaret(aMessage) {
     let direction = aMessage.json.direction;
     let granularity = aMessage.json.granularity;
     let accessible = this.vc.position;
     let accText = accessible.QueryInterface(Ci.nsIAccessibleText);
     let oldOffset = accText.caretOffset;
     let text = accText.getText(0, accText.characterCount);
 
     let start = {}, end = {};
-    if (direction === 'Previous' && !aMessage.json.atStart) {
+    if (direction === "Previous" && !aMessage.json.atStart) {
       switch (granularity) {
         case MOVEMENT_GRANULARITY_CHARACTER:
           accText.caretOffset--;
           break;
         case MOVEMENT_GRANULARITY_WORD:
           accText.getTextBeforeOffset(accText.caretOffset,
             Ci.nsIAccessibleText.BOUNDARY_WORD_START, start, end);
           accText.caretOffset = end.value === accText.caretOffset ?
             start.value : end.value;
           break;
         case MOVEMENT_GRANULARITY_PARAGRAPH:
-          let startOfParagraph = text.lastIndexOf('\n', accText.caretOffset - 1);
+          let startOfParagraph = text.lastIndexOf("\n", accText.caretOffset - 1);
           accText.caretOffset = startOfParagraph !== -1 ? startOfParagraph : 0;
           break;
       }
-    } else if (direction === 'Next' && !aMessage.json.atEnd) {
+    } else if (direction === "Next" && !aMessage.json.atEnd) {
       switch (granularity) {
         case MOVEMENT_GRANULARITY_CHARACTER:
           accText.caretOffset++;
           break;
         case MOVEMENT_GRANULARITY_WORD:
           accText.getTextAtOffset(accText.caretOffset,
                                   Ci.nsIAccessibleText.BOUNDARY_WORD_END, start, end);
           accText.caretOffset = end.value;
           break;
         case MOVEMENT_GRANULARITY_PARAGRAPH:
-          accText.caretOffset = text.indexOf('\n', accText.caretOffset + 1);
+          accText.caretOffset = text.indexOf("\n", accText.caretOffset + 1);
           break;
       }
     }
 
     this.presentCaretChange(text, oldOffset, accText.caretOffset);
   },
 
   getChildCursor: function cc_getChildCursor(aAccessible) {
     let acc = aAccessible || this.vc.position;
     if (Utils.isAliveAndVisible(acc) && acc.role === Roles.INTERNAL_FRAME) {
       let domNode = acc.DOMNode;
       let mm = this._childMessageSenders.get(domNode, null);
       if (!mm) {
         mm = Utils.getMessageManager(domNode);
-        mm.addWeakMessageListener('AccessFu:MoveCursor', this);
+        mm.addWeakMessageListener("AccessFu:MoveCursor", this);
         this._childMessageSenders.set(domNode, mm);
       }
 
       return mm;
     }
 
     return null;
   },
@@ -421,29 +421,29 @@ this.ContentControl.prototype = {
     }
 
     if (aFocus) {
       position.takeFocus();
     }
 
     // XXX: This is a silly way to make a deep copy
     let newJSON = JSON.parse(JSON.stringify(aMessage.json));
-    newJSON.origin = 'parent';
+    newJSON.origin = "parent";
     for (let attr in aReplacer) {
       newJSON[attr] = aReplacer[attr];
     }
 
     mm.sendAsyncMessage(aMessage.name, newJSON);
     return true;
   },
 
   sendToParent: function cc_sendToParent(aMessage) {
     // XXX: This is a silly way to make a deep copy
     let newJSON = JSON.parse(JSON.stringify(aMessage.json));
-    newJSON.origin = 'child';
+    newJSON.origin = "child";
     aMessage.target.sendAsyncMessage(aMessage.name, newJSON);
   },
 
   /**
    * Move cursor and/or present its location.
    * aOptions could have any of these fields:
    * - delay: in ms, before actual move is performed. Another autoMove call
    *    would cancel it. Useful if we want to wait for a possible trailing
@@ -460,17 +460,17 @@ this.ContentControl.prototype = {
     let moveFunc = () => {
       let vc = this.vc;
       let acc = aAnchor;
       let rule = aOptions.onScreenOnly ?
         TraversalRules.SimpleOnScreen : TraversalRules.Simple;
       let forcePresentFunc = () => {
         if (aOptions.forcePresent) {
           this._contentScope.get().sendAsyncMessage(
-            'AccessFu:Present', Presentation.pivotChanged(
+            "AccessFu:Present", Presentation.pivotChanged(
               vc.position, null, Ci.nsIAccessiblePivot.REASON_NONE,
               vc.startOffset, vc.endOffset, false));
         }
       };
 
       if (aOptions.noOpIfOnScreen &&
         Utils.isAliveAndVisible(vc.position, true)) {
         forcePresentFunc();
@@ -478,30 +478,30 @@ this.ContentControl.prototype = {
       }
 
       if (aOptions.moveToFocused) {
         acc = Utils.AccService.getAccessibleFor(
           this.document.activeElement) || acc;
       }
 
       let moved = false;
-      let moveMethod = aOptions.moveMethod || 'moveNext'; // default is moveNext
-      let moveFirstOrLast = moveMethod in ['moveFirst', 'moveLast'];
+      let moveMethod = aOptions.moveMethod || "moveNext"; // default is moveNext
+      let moveFirstOrLast = moveMethod in ["moveFirst", "moveLast"];
       if (!moveFirstOrLast || acc) {
         // We either need next/previous or there is an anchor we need to use.
-        moved = vc[moveFirstOrLast ? 'moveNext' : moveMethod](rule, acc, true,
+        moved = vc[moveFirstOrLast ? "moveNext" : moveMethod](rule, acc, true,
                                                               false);
       }
       if (moveFirstOrLast && !moved) {
         // We move to first/last after no anchor move happened or succeeded.
         moved = vc[moveMethod](rule, false);
       }
 
       let sentToChild = this.sendToChild(vc, {
-        name: 'AccessFu:AutoMove',
+        name: "AccessFu:AutoMove",
         json: {
           moveMethod: aOptions.moveMethod,
           moveToFocused: aOptions.moveToFocused,
           noOpIfOnScreen: true,
           forcePresent: true
         }
       }, null, true);
 
--- a/accessible/jsat/EventManager.jsm
+++ b/accessible/jsat/EventManager.jsm
@@ -1,36 +1,36 @@
 /* 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';
+"use strict";
 
 const Ci = Components.interfaces;
 const Cu = Components.utils;
 
 const TEXT_NODE = 3;
 
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Services',
-  'resource://gre/modules/Services.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Utils',
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Logger',
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Presentation',
-  'resource://gre/modules/accessibility/Presentation.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Roles',
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Events',
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'States',
-  'resource://gre/modules/accessibility/Constants.jsm');
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Services",
+  "resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Utils",
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Logger",
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Presentation",
+  "resource://gre/modules/accessibility/Presentation.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Roles",
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Events",
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "States",
+  "resource://gre/modules/accessibility/Constants.jsm");
 
-this.EXPORTED_SYMBOLS = ['EventManager'];
+this.EXPORTED_SYMBOLS = ["EventManager"];
 
 this.EventManager = function EventManager(aContentScope, aContentControl) {
   this.contentScope = aContentScope;
   this.contentControl = aContentControl;
   this.addEventListener = this.contentScope.addEventListener.bind(
     this.contentScope);
   this.removeEventListener = this.contentScope.removeEventListener.bind(
     this.contentScope);
@@ -42,108 +42,108 @@ this.EventManager = function EventManage
 };
 
 this.EventManager.prototype = {
   editState: { editing: false },
 
   start: function start() {
     try {
       if (!this._started) {
-        Logger.debug('EventManager.start');
+        Logger.debug("EventManager.start");
 
         this._started = true;
 
         AccessibilityEventObserver.addListener(this);
 
         this.webProgress.addProgressListener(this,
           (Ci.nsIWebProgress.NOTIFY_STATE_ALL |
            Ci.nsIWebProgress.NOTIFY_LOCATION));
-        this.addEventListener('wheel', this, true);
-        this.addEventListener('scroll', this, true);
-        this.addEventListener('resize', this, true);
+        this.addEventListener("wheel", this, true);
+        this.addEventListener("scroll", this, true);
+        this.addEventListener("resize", this, true);
         this._preDialogPosition = new WeakMap();
       }
-      this.present(Presentation.tabStateChanged(null, 'newtab'));
+      this.present(Presentation.tabStateChanged(null, "newtab"));
 
     } catch (x) {
-      Logger.logException(x, 'Failed to start EventManager');
+      Logger.logException(x, "Failed to start EventManager");
     }
   },
 
   // XXX: Stop is not called when the tab is closed (|TabClose| event is too
   // late). It is only called when the AccessFu is disabled explicitly.
   stop: function stop() {
     if (!this._started) {
       return;
     }
-    Logger.debug('EventManager.stop');
+    Logger.debug("EventManager.stop");
     AccessibilityEventObserver.removeListener(this);
     try {
       this._preDialogPosition = new WeakMap();
       this.webProgress.removeProgressListener(this);
-      this.removeEventListener('wheel', this, true);
-      this.removeEventListener('scroll', this, true);
-      this.removeEventListener('resize', this, true);
+      this.removeEventListener("wheel", this, true);
+      this.removeEventListener("scroll", this, true);
+      this.removeEventListener("resize", this, true);
     } catch (x) {
       // contentScope is dead.
     } finally {
       this._started = false;
     }
   },
 
   handleEvent: function handleEvent(aEvent) {
     Logger.debug(() => {
-      return ['DOMEvent', aEvent.type];
+      return ["DOMEvent", aEvent.type];
     });
 
     try {
       switch (aEvent.type) {
-      case 'wheel':
+      case "wheel":
       {
         let delta = aEvent.deltaX || aEvent.deltaY;
         this.contentControl.autoMove(
          null,
-         { moveMethod: delta > 0 ? 'moveNext' : 'movePrevious',
+         { moveMethod: delta > 0 ? "moveNext" : "movePrevious",
            onScreenOnly: true, noOpIfOnScreen: true, delay: 500 });
         break;
       }
-      case 'scroll':
-      case 'resize':
+      case "scroll":
+      case "resize":
       {
         // the target could be an element, document or window
         let window = null;
         if (aEvent.target instanceof Ci.nsIDOMWindow)
           window = aEvent.target;
         else if (aEvent.target instanceof Ci.nsIDOMDocument)
           window = aEvent.target.defaultView;
         else if (aEvent.target instanceof Ci.nsIDOMElement)
           window = aEvent.target.ownerGlobal;
         this.present(Presentation.viewportChanged(window));
         break;
       }
       }
     } catch (x) {
-      Logger.logException(x, 'Error handling DOM event');
+      Logger.logException(x, "Error handling DOM event");
     }
   },
 
   handleAccEvent: function handleAccEvent(aEvent) {
     Logger.debug(() => {
-      return ['A11yEvent', Logger.eventToString(aEvent),
+      return ["A11yEvent", Logger.eventToString(aEvent),
               Logger.accessibleToString(aEvent.accessible)];
     });
 
     // Don't bother with non-content events in firefox.
-    if (Utils.MozBuildApp == 'browser' &&
+    if (Utils.MozBuildApp == "browser" &&
         aEvent.eventType != Events.VIRTUALCURSOR_CHANGED &&
         // XXX Bug 442005 results in DocAccessible::getDocType returning
         // NS_ERROR_FAILURE. Checking for aEvent.accessibleDocument.docType ==
         // 'window' does not currently work.
         (aEvent.accessibleDocument.DOMDocument.doctype &&
-         aEvent.accessibleDocument.DOMDocument.doctype.name === 'window')) {
+         aEvent.accessibleDocument.DOMDocument.doctype.name === "window")) {
       return;
     }
 
     switch (aEvent.eventType) {
       case Events.VIRTUALCURSOR_CHANGED:
       {
         let pivot = aEvent.accessible.
           QueryInterface(Ci.nsIAccessibleDocument).virtualCursor;
@@ -170,39 +170,39 @@ this.EventManager.prototype = {
       {
         let event = aEvent.QueryInterface(Ci.nsIAccessibleStateChangeEvent);
         let state = Utils.getState(event);
         if (state.contains(States.CHECKED)) {
           if (aEvent.accessible.role === Roles.SWITCH) {
             this.present(
               Presentation.
                 actionInvoked(aEvent.accessible,
-                              event.isEnabled ? 'on' : 'off'));
+                              event.isEnabled ? "on" : "off"));
           } else {
             this.present(
               Presentation.
                 actionInvoked(aEvent.accessible,
-                              event.isEnabled ? 'check' : 'uncheck'));
+                              event.isEnabled ? "check" : "uncheck"));
           }
         } else if (state.contains(States.SELECTED)) {
           this.present(
             Presentation.
               actionInvoked(aEvent.accessible,
-                            event.isEnabled ? 'select' : 'unselect'));
+                            event.isEnabled ? "select" : "unselect"));
         }
         break;
       }
       case Events.NAME_CHANGE:
       {
         let acc = aEvent.accessible;
         if (acc === this.contentControl.vc.position) {
           this.present(Presentation.nameChanged(acc));
         } else {
           let {liveRegion, isPolite} = this._handleLiveRegion(aEvent,
-            ['text', 'all']);
+            ["text", "all"]);
           if (liveRegion) {
             this.present(Presentation.nameChanged(acc, isPolite));
           }
         }
         break;
       }
       case Events.SCROLLING_START:
       {
@@ -227,22 +227,22 @@ this.EventManager.prototype = {
           }
         }
         break;
       }
       case Events.OBJECT_ATTRIBUTE_CHANGED:
       {
         let evt = aEvent.QueryInterface(
           Ci.nsIAccessibleObjectAttributeChangedEvent);
-        if (evt.changedAttribute.toString() !== 'aria-hidden') {
+        if (evt.changedAttribute.toString() !== "aria-hidden") {
           // Only handle aria-hidden attribute change.
           break;
         }
         let hidden = Utils.isHidden(aEvent.accessible);
-        this[hidden ? '_handleHide' : '_handleShow'](evt);
+        this[hidden ? "_handleHide" : "_handleShow"](evt);
         if (this.inTest) {
           this.sendMsgFunc("AccessFu:AriaHidden", { hidden: hidden });
         }
         break;
       }
       case Events.SHOW:
       {
         this._handleShow(aEvent);
@@ -253,17 +253,17 @@ this.EventManager.prototype = {
         let evt = aEvent.QueryInterface(Ci.nsIAccessibleHideEvent);
         this._handleHide(evt);
         break;
       }
       case Events.TEXT_INSERTED:
       case Events.TEXT_REMOVED:
       {
         let {liveRegion, isPolite} = this._handleLiveRegion(aEvent,
-          ['text', 'all']);
+          ["text", "all"]);
         if (aEvent.isFromUserInput || liveRegion) {
           // Handle all text mutations coming from the user or if they happen
           // on a live region.
           this._handleText(aEvent, liveRegion, isPolite);
         }
         break;
       }
       case Events.FOCUS:
@@ -304,17 +304,17 @@ this.EventManager.prototype = {
       {
         let position = this.contentControl.vc.position;
         let target = aEvent.accessible;
         if (position === target ||
             Utils.getEmbeddedControl(position) === target) {
           this.present(Presentation.valueChanged(target));
         } else {
           let {liveRegion, isPolite} = this._handleLiveRegion(aEvent,
-            ['text', 'all']);
+            ["text", "all"]);
           if (liveRegion) {
             this.present(Presentation.valueChanged(target, isPolite));
           }
         }
       }
     }
   },
 
@@ -363,32 +363,32 @@ this.EventManager.prototype = {
       this.sendMsgFunc("AccessFu:Input", editState);
     }
 
     this.editState = editState;
   },
 
   _handleShow: function _handleShow(aEvent) {
     let {liveRegion, isPolite} = this._handleLiveRegion(aEvent,
-      ['additions', 'all']);
+      ["additions", "all"]);
     // Only handle show if it is a relevant live region.
     if (!liveRegion) {
       return;
     }
     // Show for text is handled by the EVENT_TEXT_INSERTED handler.
     if (aEvent.accessible.role === Roles.TEXT_LEAF) {
       return;
     }
     this._dequeueLiveEvent(Events.HIDE, liveRegion);
     this.present(Presentation.liveRegion(liveRegion, isPolite, false));
   },
 
   _handleHide: function _handleHide(aEvent) {
     let {liveRegion, isPolite} = this._handleLiveRegion(
-      aEvent, ['removals', 'all']);
+      aEvent, ["removals", "all"]);
     let acc = aEvent.accessible;
     if (liveRegion) {
       // Hide for text is handled by the EVENT_TEXT_REMOVED handler.
       if (acc.role === Roles.TEXT_LEAF) {
         return;
       }
       this._queueLiveEvent(Events.HIDE, liveRegion, isPolite);
     } else {
@@ -412,30 +412,30 @@ this.EventManager.prototype = {
     }
   },
 
   _handleText: function _handleText(aEvent, aLiveRegion, aIsPolite) {
     let event = aEvent.QueryInterface(Ci.nsIAccessibleTextChangeEvent);
     let isInserted = event.isInserted;
     let txtIface = aEvent.accessible.QueryInterface(Ci.nsIAccessibleText);
 
-    let text = '';
+    let text = "";
     try {
       text = txtIface.getText(0, Ci.nsIAccessibleText.TEXT_OFFSET_END_OF_TEXT);
     } catch (x) {
       // XXX we might have gotten an exception with of a
       // zero-length text. If we did, ignore it (bug #749810).
       if (txtIface.characterCount) {
         throw x;
       }
     }
     // If there are embedded objects in the text, ignore them.
     // Assuming changes to the descendants would already be handled by the
     // show/hide event.
-    let modifiedText = event.modifiedText.replace(/\uFFFC/g, '');
+    let modifiedText = event.modifiedText.replace(/\uFFFC/g, "");
     if (modifiedText != event.modifiedText && !modifiedText.trim()) {
       return;
     }
 
     if (aLiveRegion) {
       if (aEvent.eventType === Events.TEXT_REMOVED) {
         this._queueLiveEvent(Events.TEXT_REMOVED, aLiveRegion, aIsPolite,
           modifiedText);
@@ -451,23 +451,23 @@ this.EventManager.prototype = {
   },
 
   _handleLiveRegion: function _handleLiveRegion(aEvent, aRelevant) {
     if (aEvent.isFromUserInput) {
       return {};
     }
     let parseLiveAttrs = function parseLiveAttrs(aAccessible) {
       let attrs = Utils.getAttributes(aAccessible);
-      if (attrs['container-live']) {
+      if (attrs["container-live"]) {
         return {
-          live: attrs['container-live'],
-          relevant: attrs['container-relevant'] || 'additions text',
-          busy: attrs['container-busy'],
-          atomic: attrs['container-atomic'],
-          memberOf: attrs['member-of']
+          live: attrs["container-live"],
+          relevant: attrs["container-relevant"] || "additions text",
+          busy: attrs["container-busy"],
+          atomic: attrs["container-atomic"],
+          memberOf: attrs["member-of"]
         };
       }
       return null;
     };
     // XXX live attributes are not set for hidden accessibles yet. Need to
     // climb up the tree to check for them.
     let getLiveAttributes = function getLiveAttributes(aEvent) {
       let liveAttrs = parseLiveAttrs(aEvent.accessible);
@@ -481,30 +481,30 @@ this.EventManager.prototype = {
           return liveAttrs;
         }
         parent = parent.parent
       }
       return {};
     };
     let {live, relevant, /* busy, atomic, memberOf */ } = getLiveAttributes(aEvent);
     // If container-live is not present or is set to |off| ignore the event.
-    if (!live || live === 'off') {
+    if (!live || live === "off") {
       return {};
     }
     // XXX: support busy and atomic.
 
     // Determine if the type of the mutation is relevant. Default is additions
     // and text.
     let isRelevant = Utils.matchAttributeValue(relevant, aRelevant);
     if (!isRelevant) {
       return {};
     }
     return {
       liveRegion: aEvent.accessible,
-      isPolite: live === 'polite'
+      isPolite: live === "polite"
     };
   },
 
   _dequeueLiveEvent: function _dequeueLiveEvent(aEventType, aLiveRegion) {
     let domNode = aLiveRegion.DOMNode;
     if (this._liveEventQueue && this._liveEventQueue.has(domNode)) {
       let queue = this._liveEventQueue.get(domNode);
       let nextEvent = queue[0];
@@ -537,39 +537,39 @@ this.EventManager.prototype = {
     }
   },
 
   present: function present(aPresentationData) {
     this.sendMsgFunc("AccessFu:Present", aPresentationData);
   },
 
   onStateChange: function onStateChange(aWebProgress, aRequest, aStateFlags, aStatus) {
-    let tabstate = '';
+    let tabstate = "";
 
     let loadingState = Ci.nsIWebProgressListener.STATE_TRANSFERRING |
       Ci.nsIWebProgressListener.STATE_IS_DOCUMENT;
     let loadedState = Ci.nsIWebProgressListener.STATE_STOP |
       Ci.nsIWebProgressListener.STATE_IS_NETWORK;
 
     if ((aStateFlags & loadingState) == loadingState) {
-      tabstate = 'loading';
+      tabstate = "loading";
     } else if ((aStateFlags & loadedState) == loadedState &&
                !aWebProgress.isLoadingDocument) {
-      tabstate = 'loaded';
+      tabstate = "loaded";
     }
 
     if (tabstate) {
       let docAcc = Utils.AccService.getAccessibleFor(aWebProgress.DOMWindow.document);
       this.present(Presentation.tabStateChanged(docAcc, tabstate));
     }
   },
 
   onLocationChange: function onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {
     let docAcc = Utils.AccService.getAccessibleFor(aWebProgress.DOMWindow.document);
-    this.present(Presentation.tabStateChanged(docAcc, 'newdoc'));
+    this.present(Presentation.tabStateChanged(docAcc, "newdoc"));
   },
 
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIWebProgressListener,
                                          Ci.nsISupportsWeakReference,
                                          Ci.nsISupports,
                                          Ci.nsIObserver])
 };
 
@@ -592,28 +592,28 @@ const AccessibilityEventObserver = {
 
   /**
    * Start an AccessibilityEventObserver.
    */
   start: function start() {
     if (this.started || this.listenerCount === 0) {
       return;
     }
-    Services.obs.addObserver(this, 'accessible-event');
+    Services.obs.addObserver(this, "accessible-event");
     this.started = true;
   },
 
   /**
    * Stop an AccessibilityEventObserver.
    */
   stop: function stop() {
     if (!this.started) {
       return;
     }
-    Services.obs.removeObserver(this, 'accessible-event');
+    Services.obs.removeObserver(this, "accessible-event");
     // Clean up all registered event managers.
     this.eventManagers = new WeakMap();
     this.listenerCount = 0;
     this.started = false;
   },
 
   /**
    * Register an EventManager and start listening to the
@@ -624,17 +624,17 @@ const AccessibilityEventObserver = {
    */
   addListener: function addListener(aEventManager) {
     let content = aEventManager.contentScope.content;
     if (!this.eventManagers.has(content)) {
       this.listenerCount++;
     }
     this.eventManagers.set(content, aEventManager);
     // Since at least one EventManager was registered, start listening.
-    Logger.debug('AccessibilityEventObserver.addListener. Total:',
+    Logger.debug("AccessibilityEventObserver.addListener. Total:",
       this.listenerCount);
     this.start();
   },
 
   /**
    * Unregister an EventManager and, optionally, stop listening to the
    * 'accessible-event' messages.
    *
@@ -642,17 +642,17 @@ const AccessibilityEventObserver = {
    *        An EventManager object that was stopped in the specific content.
    */
   removeListener: function removeListener(aEventManager) {
     let content = aEventManager.contentScope.content;
     if (!this.eventManagers.delete(content)) {
       return;
     }
     this.listenerCount--;
-    Logger.debug('AccessibilityEventObserver.removeListener. Total:',
+    Logger.debug("AccessibilityEventObserver.removeListener. Total:",
       this.listenerCount);
     if (this.listenerCount === 0) {
       // If there are no EventManagers registered at the moment, stop listening
       // to the 'accessible-event' messages.
       this.stop();
     }
   },
 
@@ -674,42 +674,42 @@ const AccessibilityEventObserver = {
     }
     return this.getListener(parent);
   },
 
   /**
    * Handle the 'accessible-event' message.
    */
   observe: function observe(aSubject, aTopic, aData) {
-    if (aTopic !== 'accessible-event') {
+    if (aTopic !== "accessible-event") {
       return;
     }
     let event = aSubject.QueryInterface(Ci.nsIAccessibleEvent);
     if (!event.accessibleDocument) {
       Logger.warning(
-        'AccessibilityEventObserver.observe: no accessible document:',
+        "AccessibilityEventObserver.observe: no accessible document:",
         Logger.eventToString(event), "accessible:",
         Logger.accessibleToString(event.accessible));
       return;
     }
     let content = event.accessibleDocument.window;
     // Match the content window to its EventManager.
     let eventManager = this.getListener(content);
     if (!eventManager || !eventManager._started) {
-      if (Utils.MozBuildApp === 'browser' &&
+      if (Utils.MozBuildApp === "browser" &&
           !(content instanceof Ci.nsIDOMChromeWindow)) {
         Logger.warning(
-          'AccessibilityEventObserver.observe: ignored event:',
+          "AccessibilityEventObserver.observe: ignored event:",
           Logger.eventToString(event), "accessible:",
           Logger.accessibleToString(event.accessible), "document:",
           Logger.accessibleToString(event.accessibleDocument));
       }
       return;
     }
     try {
       eventManager.handleAccEvent(event);
     } catch (x) {
-      Logger.logException(x, 'Error handing accessible event');
+      Logger.logException(x, "Error handing accessible event");
     } finally {
       return;
     }
   }
 };
--- a/accessible/jsat/Gestures.jsm
+++ b/accessible/jsat/Gestures.jsm
@@ -29,34 +29,34 @@
 
   DoubleTapHoldEnd -> Explore          (x)
 
         ExploreEnd -> Explore          (x)
 
            Explore -> ExploreEnd       (v)
 ******************************************************************************/
 
-'use strict';
+"use strict";
 
 const Cu = Components.utils;
 
-this.EXPORTED_SYMBOLS = ['GestureSettings', 'GestureTracker']; // jshint ignore:line
+this.EXPORTED_SYMBOLS = ["GestureSettings", "GestureTracker"]; // jshint ignore:line
 
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 
-XPCOMUtils.defineLazyModuleGetter(this, 'Utils', // jshint ignore:line
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Logger', // jshint ignore:line
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'setTimeout', // jshint ignore:line
-  'resource://gre/modules/Timer.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'clearTimeout', // jshint ignore:line
-  'resource://gre/modules/Timer.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'PromiseUtils', // jshint ignore:line
-  'resource://gre/modules/PromiseUtils.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, "Utils", // jshint ignore:line
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Logger", // jshint ignore:line
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "setTimeout", // jshint ignore:line
+  "resource://gre/modules/Timer.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "clearTimeout", // jshint ignore:line
+  "resource://gre/modules/Timer.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PromiseUtils", // jshint ignore:line
+  "resource://gre/modules/PromiseUtils.jsm");
 
 // Default maximum duration of swipe
 const SWIPE_MAX_DURATION = 200;
 // Default maximum amount of time allowed for a gesture to be considered a
 // multitouch
 const MAX_MULTITOUCH = 125;
 // Default maximum consecutive pointer event timeout
 const MAX_CONSECUTIVE_GESTURE_DELAY = 200;
@@ -70,17 +70,17 @@ const TAP_MAX_RADIUS = 0.2;
 // consequent pointer move lines.
 const DIRECTNESS_COEFF = 1.44;
 // Amount in inches from the edges of the screen for it to be an edge swipe
 const EDGE = 0.1;
 // Multiply timeouts by this constant, x2 works great too for slower users.
 const TIMEOUT_MULTIPLIER = 1;
 // A single pointer down/up sequence periodically precedes the tripple swipe
 // gesture on Android. This delay acounts for that.
-const IS_ANDROID = Utils.MozBuildApp === 'mobile/android' &&
+const IS_ANDROID = Utils.MozBuildApp === "mobile/android" &&
   Utils.AndroidSdkVersion >= 14;
 
 /**
  * A point object containing distance travelled data.
  * @param {Object} aPoint A point object that looks like: {
  *   x: x coordinate in pixels,
  *   y: y coordinate in pixels
  * }
@@ -197,35 +197,35 @@ this.GestureTracker = { // jshint ignore
    * Create a new gesture object and attach resolution handler to it as well as
    * handle the incoming pointer event.
    * @param  {Object} aDetail A new pointer event detail.
    * @param  {Number} aTimeStamp A new pointer event timeStamp.
    * @param  {Function} aGesture A gesture constructor (default: Tap).
    */
   _init: function GestureTracker__init(aDetail, aTimeStamp, aGesture) {
     // Only create a new gesture on |pointerdown| event.
-    if (aDetail.type !== 'pointerdown') {
+    if (aDetail.type !== "pointerdown") {
       return;
     }
     let GestureConstructor = aGesture || (IS_ANDROID ? DoubleTap : Tap);
     this._create(GestureConstructor);
     this._update(aDetail, aTimeStamp);
   },
 
   /**
    * Handle the incoming pointer event with the existing gesture object(if
    * present) or with the newly created one.
    * @param  {Object} aDetail A new pointer event detail.
    * @param  {Number} aTimeStamp A new pointer event timeStamp.
    */
   handle: function GestureTracker_handle(aDetail, aTimeStamp) {
     Logger.gesture(() => {
-      return ['Pointer event', Utils.dpi, 'at:', aTimeStamp, JSON.stringify(aDetail)];
+      return ["Pointer event", Utils.dpi, "at:", aTimeStamp, JSON.stringify(aDetail)];
     });
-    this[this.current ? '_update' : '_init'](aDetail, aTimeStamp);
+    this[this.current ? "_update" : "_init"](aDetail, aTimeStamp);
   },
 
   /**
    * Create a new gesture object and attach resolution handler to it.
    * @param  {Function} aGesture A gesture constructor.
    * @param  {Number} aTimeStamp An original pointer event timeStamp.
    * @param  {Array} aPoints All changed points associated with the new pointer
    * event.
@@ -274,17 +274,17 @@ this.GestureTracker = { // jshint ignore
  * @param  {String} aType A gesture type.
  * @param  {Object} aPoints Gesture's points.
  * @param  {String} xKey A default key for the x coordinate. Default is
  * 'startX'.
  * @param  {String} yKey A default key for the y coordinate. Default is
  * 'startY'.
  * @return {Object} a mozAccessFuGesture detail structure.
  */
-function compileDetail(aType, aPoints, keyMap = {x: 'startX', y: 'startY'}) {
+function compileDetail(aType, aPoints, keyMap = {x: "startX", y: "startY"}) {
   let touches = [];
   let maxDeltaX = 0;
   let maxDeltaY = 0;
   for (let identifier in aPoints) {
     let point = aPoints[identifier];
     let touch = {};
     for (let key in keyMap) {
       touch[key] = point[keyMap[key]];
@@ -316,17 +316,17 @@ function compileDetail(aType, aPoints, k
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * Default is an empty object.
  * @param {?String} aLastEvent Last pointer event type.
  */
 function Gesture(aTimeStamp, aPoints = {}, aLastEvent = undefined) {
   this.startTime = Date.now();
-  Logger.gesture('Creating', this.id, 'gesture.');
+  Logger.gesture("Creating", this.id, "gesture.");
   this.points = aPoints;
   this.lastEvent = aLastEvent;
   this._deferred = PromiseUtils.defer();
   // Call this._handleResolve or this._handleReject when the promise is
   // fulfilled with either resolve or reject.
   this.promise = this._deferred.promise.then(this._handleResolve.bind(this),
     this._handleReject.bind(this));
   this.startTimer(aTimeStamp);
@@ -344,32 +344,32 @@ Gesture.prototype = {
     // reject this gesture promise.
     return GestureSettings.maxConsecutiveGestureDelay;
   },
 
   /**
    * Clear the existing timer.
    */
   clearTimer: function Gesture_clearTimer() {
-    Logger.gesture('clearTimeout', this.type);
+    Logger.gesture("clearTimeout", this.type);
     clearTimeout(this._timer);
     delete this._timer;
   },
 
   /**
    * Start the timer for gesture timeout.
    * @param {Number} aTimeStamp An original pointer event's timeStamp that
    * started the gesture resolution sequence.
    */
   startTimer: function Gesture_startTimer(aTimeStamp) {
-    Logger.gesture('startTimer', this.type);
+    Logger.gesture("startTimer", this.type);
     this.clearTimer();
     let delay = this._getDelay(aTimeStamp);
     let handler = () => {
-      Logger.gesture('timer handler');
+      Logger.gesture("timer handler");
       this.clearTimer();
       if (!this._inProgress) {
         this._deferred.reject();
       } else if (this._rejectToOnWait) {
         this._deferred.reject(this._rejectToOnWait);
       }
     };
     if (delay <= 0) {
@@ -403,17 +403,17 @@ Gesture.prototype = {
    */
   _update: function Gesture__update(aPoints, aType, aCanCreate = false, aNeedComplete = false) {
     let complete;
     let lastEvent;
     for (let point of aPoints) {
       let identifier = point.identifier;
       let gesturePoint = this.points[identifier];
       if (gesturePoint) {
-        if (aType === 'pointerdown' && aCanCreate) {
+        if (aType === "pointerdown" && aCanCreate) {
           // scratch the previous pointer with that id.
           this.points[identifier] = new Point(point);
         } else {
           gesturePoint.update(point);
         }
         if (aNeedComplete) {
           // Since the gesture is completing and at least one of the gesture
           // points is updated, set the return value to true.
@@ -435,49 +435,49 @@ Gesture.prototype = {
     return complete;
   },
 
   /**
    * Emit a mozAccessFuGesture (when the gesture is resolved).
    * @param  {Object} aDetail a compiled mozAccessFuGesture detail structure.
    */
   _emit: function Gesture__emit(aDetail) {
-    let evt = new Utils.win.CustomEvent('mozAccessFuGesture', {
+    let evt = new Utils.win.CustomEvent("mozAccessFuGesture", {
       bubbles: true,
       cancelable: true,
       detail: aDetail
     });
     Utils.win.dispatchEvent(evt);
   },
 
   /**
    * Handle the pointer down event.
    * @param  {Array} aPoints A new pointer down points.
    * @param  {Number} aTimeStamp A new pointer down timeStamp.
    */
   pointerdown: function Gesture_pointerdown(aPoints, aTimeStamp) {
     this._inProgress = true;
-    this._update(aPoints, 'pointerdown',
+    this._update(aPoints, "pointerdown",
       aTimeStamp - this.startTime < GestureSettings.maxMultitouch);
   },
 
   /**
    * Handle the pointer move event.
    * @param  {Array} aPoints A new pointer move points.
    */
   pointermove: function Gesture_pointermove(aPoints) {
-    this._update(aPoints, 'pointermove');
+    this._update(aPoints, "pointermove");
   },
 
   /**
    * Handle the pointer up event.
    * @param  {Array} aPoints A new pointer up points.
    */
   pointerup: function Gesture_pointerup(aPoints) {
-    let complete = this._update(aPoints, 'pointerup', false, true);
+    let complete = this._update(aPoints, "pointerup", false, true);
     if (complete) {
       this._deferred.resolve();
     }
   },
 
   /**
    * A subsequent gesture constructor to resolve the current one to. E.g.
    * tap->doubletap, dwell->dwellend, etc.
@@ -501,17 +501,17 @@ Gesture.prototype = {
    *   id: current gesture id,
    *   gestureType: an optional subsequent gesture constructor.
    * }
    */
   _handleResolve: function Gesture__handleResolve() {
     if (this.isComplete) {
       return;
     }
-    Logger.gesture('Resolving', this.id, 'gesture.');
+    Logger.gesture("Resolving", this.id, "gesture.");
     this.isComplete = true;
     this.clearTimer();
     let detail = this.compile();
     if (detail) {
       this._emit(detail);
     }
     return {
       id: this.id,
@@ -526,17 +526,17 @@ Gesture.prototype = {
    *   id: current gesture id,
    *   gestureType: an optional subsequent gesture constructor.
    * }
    */
   _handleReject: function Gesture__handleReject(aRejectTo) {
     if (this.isComplete) {
       return;
     }
-    Logger.gesture('Rejecting', this.id, 'gesture.');
+    Logger.gesture("Rejecting", this.id, "gesture.");
     this.isComplete = true;
     this.clearTimer();
     return {
       id: this.id,
       gestureType: aRejectTo
     };
   },
 
@@ -553,26 +553,26 @@ Gesture.prototype = {
 
 /**
  * A mixin for an explore related object.
  */
 function ExploreGesture() {
   this.compile = () => {
     // Unlike most of other gestures explore based gestures compile using the
     // current point position and not the start one.
-    return compileDetail(this.type, this.points, {x: 'x', y: 'y'});
+    return compileDetail(this.type, this.points, {x: "x", y: "y"});
   };
 }
 
 /**
  * Check the in progress gesture for completion.
  */
 function checkProgressGesture(aGesture) {
   aGesture._inProgress = true;
-  if (aGesture.lastEvent === 'pointerup') {
+  if (aGesture.lastEvent === "pointerup") {
     if (aGesture.test) {
       aGesture.test(true);
     }
     aGesture._deferred.resolve();
   }
 }
 
 /**
@@ -624,17 +624,17 @@ TravelGesture.prototype.test = function 
 function DwellEnd(aTimeStamp, aPoints, aLastEvent) {
   this._inProgress = true;
   // If the pointer travels, reject to Explore.
   TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
   checkProgressGesture(this);
 }
 
 DwellEnd.prototype = Object.create(TravelGesture.prototype);
-DwellEnd.prototype.type = 'dwellend';
+DwellEnd.prototype.type = "dwellend";
 
 /**
  * TapHoldEnd gesture. This gesture can be represented as the following diagram:
  * pointerdown-pointerup-pointerdown-*wait*-pointerup.
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
@@ -642,17 +642,17 @@ DwellEnd.prototype.type = 'dwellend';
 function TapHoldEnd(aTimeStamp, aPoints, aLastEvent) {
   this._inProgress = true;
   // If the pointer travels, reject to Explore.
   TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
   checkProgressGesture(this);
 }
 
 TapHoldEnd.prototype = Object.create(TravelGesture.prototype);
-TapHoldEnd.prototype.type = 'tapholdend';
+TapHoldEnd.prototype.type = "tapholdend";
 
 /**
  * DoubleTapHoldEnd gesture. This gesture can be represented as the following
  * diagram:
  * pointerdown-pointerup-pointerdown-pointerup-pointerdown-*wait*-pointerup.
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
@@ -661,17 +661,17 @@ TapHoldEnd.prototype.type = 'tapholdend'
 function DoubleTapHoldEnd(aTimeStamp, aPoints, aLastEvent) {
   this._inProgress = true;
   // If the pointer travels, reject to Explore.
   TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
   checkProgressGesture(this);
 }
 
 DoubleTapHoldEnd.prototype = Object.create(TravelGesture.prototype);
-DoubleTapHoldEnd.prototype.type = 'doubletapholdend';
+DoubleTapHoldEnd.prototype.type = "doubletapholdend";
 
 /**
  * A common tap gesture object.
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
  * @param {Function} aRejectToOnWait A constructor for the next gesture to
@@ -695,17 +695,17 @@ TapGesture.prototype._getDelay = functio
   // If, for TapGesture, no pointermove or pointerup happens within the
   // GestureSettings.dwellThreshold, reject.
   // Note: the original pointer event's timeStamp is irrelevant here.
   return GestureSettings.dwellThreshold;
 };
 
 TapGesture.prototype.pointerup = function TapGesture_pointerup(aPoints) {
     if (this._rejectToOnPointerDown) {
-      let complete = this._update(aPoints, 'pointerup', false, true);
+      let complete = this._update(aPoints, "pointerup", false, true);
       if (complete) {
         this.clearTimer();
         if (GestureSettings.maxGestureResolveTimeout) {
           this._pointerUpTimer = setTimeout(() => {
             clearTimeout(this._pointerUpTimer);
             delete this._pointerUpTimer;
             this._deferred.resolve();
           }, GestureSettings.maxGestureResolveTimeout);
@@ -737,48 +737,48 @@ TapGesture.prototype.pointerdown = funct
  * @param {?String} aLastEvent Last pointer event type.
  */
 function Tap(aTimeStamp, aPoints, aLastEvent) {
   // If the pointer travels, reject to Swipe.
   TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, Dwell, Swipe, DoubleTap);
 }
 
 Tap.prototype = Object.create(TapGesture.prototype);
-Tap.prototype.type = 'tap';
+Tap.prototype.type = "tap";
 
 
 /**
  * Double Tap gesture.
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
  */
 function DoubleTap(aTimeStamp, aPoints, aLastEvent) {
   this._inProgress = true;
   TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, TapHold, null, TripleTap);
 }
 
 DoubleTap.prototype = Object.create(TapGesture.prototype);
-DoubleTap.prototype.type = 'doubletap';
+DoubleTap.prototype.type = "doubletap";
 
 /**
  * Triple Tap gesture.
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
  */
 function TripleTap(aTimeStamp, aPoints, aLastEvent) {
   this._inProgress = true;
   TapGesture.call(this, aTimeStamp, aPoints, aLastEvent, DoubleTapHold, null, null);
 }
 
 TripleTap.prototype = Object.create(TapGesture.prototype);
-TripleTap.prototype.type = 'tripletap';
+TripleTap.prototype.type = "tripletap";
 
 /**
  * Common base object for gestures that are created as resolved.
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
  */
@@ -797,63 +797,63 @@ ResolvedGesture.prototype = Object.creat
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
  */
 function Dwell(aTimeStamp, aPoints, aLastEvent) {
   ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
 }
 
 Dwell.prototype = Object.create(ResolvedGesture.prototype);
-Dwell.prototype.type = 'dwell';
+Dwell.prototype.type = "dwell";
 Dwell.prototype.resolveTo = DwellEnd;
 
 /**
  * TapHold gesture
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
  */
 function TapHold(aTimeStamp, aPoints, aLastEvent) {
   ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
 }
 
 TapHold.prototype = Object.create(ResolvedGesture.prototype);
-TapHold.prototype.type = 'taphold';
+TapHold.prototype.type = "taphold";
 TapHold.prototype.resolveTo = TapHoldEnd;
 
 /**
  * DoubleTapHold gesture
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
  */
 function DoubleTapHold(aTimeStamp, aPoints, aLastEvent) {
   ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
 }
 
 DoubleTapHold.prototype = Object.create(ResolvedGesture.prototype);
-DoubleTapHold.prototype.type = 'doubletaphold';
+DoubleTapHold.prototype.type = "doubletaphold";
 DoubleTapHold.prototype.resolveTo = DoubleTapHoldEnd;
 
 /**
  * Explore gesture
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
  */
 function Explore(aTimeStamp, aPoints, aLastEvent) {
   ExploreGesture.call(this);
   ResolvedGesture.call(this, aTimeStamp, aPoints, aLastEvent);
 }
 
 Explore.prototype = Object.create(ResolvedGesture.prototype);
-Explore.prototype.type = 'explore';
+Explore.prototype.type = "explore";
 Explore.prototype.resolveTo = ExploreEnd;
 
 /**
  * ExploreEnd gesture.
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
@@ -862,34 +862,34 @@ function ExploreEnd(aTimeStamp, aPoints,
   this._inProgress = true;
   ExploreGesture.call(this);
   // If the pointer travels, reject to Explore.
   TravelGesture.call(this, aTimeStamp, aPoints, aLastEvent);
   checkProgressGesture(this);
 }
 
 ExploreEnd.prototype = Object.create(TravelGesture.prototype);
-ExploreEnd.prototype.type = 'exploreend';
+ExploreEnd.prototype.type = "exploreend";
 
 /**
  * Swipe gesture.
  * @param {Number} aTimeStamp An original pointer event's timeStamp that started
  * the gesture resolution sequence.
  * @param {Object} aPoints An existing set of points (from previous events).
  * @param {?String} aLastEvent Last pointer event type.
  */
 function Swipe(aTimeStamp, aPoints, aLastEvent) {
   this._inProgress = true;
   this._rejectToOnWait = Explore;
   Gesture.call(this, aTimeStamp, aPoints, aLastEvent);
   checkProgressGesture(this);
 }
 
 Swipe.prototype = Object.create(Gesture.prototype);
-Swipe.prototype.type = 'swipe';
+Swipe.prototype.type = "swipe";
 Swipe.prototype._getDelay = function Swipe__getDelay(aTimeStamp) {
   // Swipe should be completed within the GestureSettings.swipeMaxDuration from
   // the initial pointer down event.
   return GestureSettings.swipeMaxDuration - this.startTime + aTimeStamp;
 };
 
 /**
  * Determine wither the gesture was Swipe or Explore.
@@ -919,37 +919,37 @@ Swipe.prototype.test = function Swipe_te
 
 /**
  * Compile a swipe related mozAccessFuGesture event detail.
  * @return {Object} A mozAccessFuGesture detail object.
  */
 Swipe.prototype.compile = function Swipe_compile() {
   let type = this.type;
   let detail = compileDetail(type, this.points,
-    {x1: 'startX', y1: 'startY', x2: 'x', y2: 'y'});
+    {x1: "startX", y1: "startY", x2: "x", y2: "y"});
   let deltaX = detail.deltaX;
   let deltaY = detail.deltaY;
   let edge = EDGE * Utils.dpi;
   if (Math.abs(deltaX) > Math.abs(deltaY)) {
     // Horizontal swipe.
     let startPoints = detail.touches.map(touch => touch.x1);
     if (deltaX > 0) {
-      detail.type = type + 'right';
+      detail.type = type + "right";
       detail.edge = Math.min.apply(null, startPoints) <= edge;
     } else {
-      detail.type = type + 'left';
+      detail.type = type + "left";
       detail.edge =
         Utils.win.screen.width - Math.max.apply(null, startPoints) <= edge;
     }
   } else {
     // Vertical swipe.
     let startPoints = detail.touches.map(touch => touch.y1);
     if (deltaY > 0) {
-      detail.type = type + 'down';
+      detail.type = type + "down";
       detail.edge = Math.min.apply(null, startPoints) <= edge;
     } else {
-      detail.type = type + 'up';
+      detail.type = type + "up";
       detail.edge =
         Utils.win.screen.height - Math.max.apply(null, startPoints) <= edge;
     }
   }
   return detail;
 };
--- a/accessible/jsat/OutputGenerator.jsm
+++ b/accessible/jsat/OutputGenerator.jsm
@@ -1,40 +1,40 @@
 /* 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/. */
 
 /* exported UtteranceGenerator, BrailleGenerator */
 
-'use strict';
+"use strict";
 
 const {utils: Cu, interfaces: Ci} = Components;
 
 const INCLUDE_DESC = 0x01;
 const INCLUDE_NAME = 0x02;
 const INCLUDE_VALUE = 0x04;
 const NAME_FROM_SUBTREE_RULE = 0x10;
 const IGNORE_EXPLICIT_NAME = 0x20;
 
 const OUTPUT_DESC_FIRST = 0;
 const OUTPUT_DESC_LAST = 1;
 
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Utils', // jshint ignore:line
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'PrefCache', // jshint ignore:line
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Logger', // jshint ignore:line
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Roles', // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'States', // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Utils", // jshint ignore:line
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PrefCache", // jshint ignore:line
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Logger", // jshint ignore:line
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Roles", // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "States", // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
 
-this.EXPORTED_SYMBOLS = ['UtteranceGenerator', 'BrailleGenerator']; // jshint ignore:line
+this.EXPORTED_SYMBOLS = ["UtteranceGenerator", "BrailleGenerator"]; // jshint ignore:line
 
 var OutputGenerator = {
 
   defaultOutputOrder: OUTPUT_DESC_LAST,
 
   /**
    * Generates output for a PivotContext.
    * @param {PivotContext} aContext object that generates and caches
@@ -52,17 +52,17 @@ var OutputGenerator = {
     };
     let ignoreSubtree = function ignoreSubtree(aAccessible) {
       let roleString = Utils.AccService.getStringRole(aAccessible.role);
       let nameRule = self.roleRuleMap[roleString] || 0;
       // Ignore subtree if the name is explicit and the role's name rule is the
       // NAME_FROM_SUBTREE_RULE.
       return (((nameRule & INCLUDE_VALUE) && aAccessible.value) ||
               ((nameRule & NAME_FROM_SUBTREE_RULE) &&
-               (Utils.getAttributes(aAccessible)['explicit-name'] === 'true' &&
+               (Utils.getAttributes(aAccessible)["explicit-name"] === "true" &&
                !(nameRule & IGNORE_EXPLICIT_NAME))));
     };
 
     let contextStart = this._getContextStart(aContext);
 
     if (this.outputOrder === OUTPUT_DESC_FIRST) {
       contextStart.forEach(addOutput);
       addOutput(aContext.accessible);
@@ -161,51 +161,51 @@ var OutputGenerator = {
   /**
    * Adds an accessible name and description to the output if available.
    * @param {Array} aOutput Output array.
    * @param {nsIAccessible} aAccessible current accessible object.
    * @param {Number} aFlags output flags.
    */
   _addName: function _addName(aOutput, aAccessible, aFlags) {
     let name;
-    if ((Utils.getAttributes(aAccessible)['explicit-name'] === 'true' &&
+    if ((Utils.getAttributes(aAccessible)["explicit-name"] === "true" &&
          !(aFlags & IGNORE_EXPLICIT_NAME)) || (aFlags & INCLUDE_NAME)) {
       name = aAccessible.name;
     }
 
     let description = aAccessible.description;
     if (description) {
       // Compare against the calculated name unconditionally, regardless of name rule,
       // so we can make sure we don't speak duplicated descriptions
       let tmpName = name || aAccessible.name;
       if (tmpName && (description !== tmpName)) {
-        name = name || '';
+        name = name || "";
         name = this.outputOrder === OUTPUT_DESC_FIRST ?
-          description + ' - ' + name :
-          name + ' - ' + description;
+          description + " - " + name :
+          name + " - " + description;
       }
     }
 
     if (!name || !name.trim()) {
       return;
     }
-    aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift'](name);
+    aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? "push" : "unshift"](name);
   },
 
   /**
    * Adds a landmark role to the output if available.
    * @param {Array} aOutput Output array.
    * @param {nsIAccessible} aAccessible current accessible object.
    */
   _addLandmark: function _addLandmark(aOutput, aAccessible) {
     let landmarkName = Utils.getLandmarkName(aAccessible);
     if (!landmarkName) {
       return;
     }
-    aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'unshift' : 'push']({
+    aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? "unshift" : "push"]({
       string: landmarkName
     });
   },
 
   /**
    * Adds math roles to the output, for a MathML accessible.
    * @param {Array} aOutput Output array.
    * @param {nsIAccessible} aAccessible current accessible object.
@@ -227,198 +227,198 @@ var OutputGenerator = {
       case Roles.MATHML_MULTISCRIPTS:
       case Roles.MATHML_OVER:
       case Roles.MATHML_SUB:
       case Roles.MATHML_SUB_SUP:
       case Roles.MATHML_SUP:
       case Roles.MATHML_UNDER:
       case Roles.MATHML_UNDER_OVER:
         // For scripted accessibles, use the string 'mathmlscripted'.
-        roleStr = 'mathmlscripted';
+        roleStr = "mathmlscripted";
         break;
       case Roles.MATHML_FRACTION:
         // From a semantic point of view, the only important point is to
         // distinguish between fractions that have a bar and those that do not.
         // Per the MathML 3 spec, the latter happens iff the linethickness
         // attribute is of the form [zero-float][optional-unit]. In that case,
         // we use the string 'mathmlfractionwithoutbar'.
         let linethickness = Utils.getAttributes(aAccessible).linethickness;
         if (linethickness) {
             let numberMatch = linethickness.match(/^(?:\d|\.)+/);
             if (numberMatch && !parseFloat(numberMatch[0])) {
-                roleStr += 'withoutbar';
+                roleStr += "withoutbar";
             }
         }
         break;
       default:
         // Otherwise, do not output the actual role.
         roleStr = null;
         break;
     }
 
     // Get the math role based on the position in the parent accessible
     // (e.g. numerator for the first child of a mathmlfraction).
     let mathRole = Utils.getMathRole(aAccessible);
     if (mathRole) {
-      aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift']({
+      aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? "push" : "unshift"]({
         string: this._getOutputName(mathRole)});
     }
     if (roleStr) {
-      aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift']({
+      aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? "push" : "unshift"]({
         string: this._getOutputName(roleStr)});
     }
   },
 
   /**
    * Adds MathML menclose notations to the output.
    * @param {Array} aOutput Output array.
    * @param {nsIAccessible} aAccessible current accessible object.
    */
   _addMencloseNotations: function _addMencloseNotations(aOutput, aAccessible) {
-    let notations = Utils.getAttributes(aAccessible).notation || 'longdiv';
-    aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift'].apply(
-      aOutput, notations.split(' ').map(notation => {
-        return { string: this._getOutputName('notation-' + notation) };
+    let notations = Utils.getAttributes(aAccessible).notation || "longdiv";
+    aOutput[this.outputOrder === OUTPUT_DESC_FIRST ? "push" : "unshift"].apply(
+      aOutput, notations.split(" ").map(notation => {
+        return { string: this._getOutputName("notation-" + notation) };
       }));
   },
 
   /**
    * Adds an entry type attribute to the description if available.
    * @param {Array} aOutput Output array.
    * @param {nsIAccessible} aAccessible current accessible object.
    * @param {String} aRoleStr aAccessible's role string.
    */
   _addType: function _addType(aOutput, aAccessible, aRoleStr) {
-    if (aRoleStr !== 'entry') {
+    if (aRoleStr !== "entry") {
       return;
     }
 
-    let typeName = Utils.getAttributes(aAccessible)['text-input-type'];
+    let typeName = Utils.getAttributes(aAccessible)["text-input-type"];
     // Ignore the the input type="text" case.
-    if (!typeName || typeName === 'text') {
+    if (!typeName || typeName === "text") {
       return;
     }
-    aOutput.push({string: 'textInputType_' + typeName});
+    aOutput.push({string: "textInputType_" + typeName});
   },
 
   _addState: function _addState(aOutput, aState, aRoleStr) {}, // jshint ignore:line
 
   _addRole: function _addRole(aOutput, aAccessible, aRoleStr) {}, // jshint ignore:line
 
   get outputOrder() {
     if (!this._utteranceOrder) {
-      this._utteranceOrder = new PrefCache('accessibility.accessfu.utterance');
+      this._utteranceOrder = new PrefCache("accessibility.accessfu.utterance");
     }
-    return typeof this._utteranceOrder.value === 'number' ?
+    return typeof this._utteranceOrder.value === "number" ?
       this._utteranceOrder.value : this.defaultOutputOrder;
   },
 
   _getOutputName: function _getOutputName(aName) {
-    return aName.replace(/\s/g, '');
+    return aName.replace(/\s/g, "");
   },
 
   roleRuleMap: {
-    'menubar': INCLUDE_DESC,
-    'scrollbar': INCLUDE_DESC,
-    'grip': INCLUDE_DESC,
-    'alert': INCLUDE_DESC | INCLUDE_NAME,
-    'menupopup': INCLUDE_DESC,
-    'menuitem': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'tooltip': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'columnheader': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'rowheader': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'column': NAME_FROM_SUBTREE_RULE,
-    'row': NAME_FROM_SUBTREE_RULE,
-    'cell': INCLUDE_DESC | INCLUDE_NAME,
-    'application': INCLUDE_NAME,
-    'document': INCLUDE_NAME,
-    'grouping': INCLUDE_DESC | INCLUDE_NAME,
-    'toolbar': INCLUDE_DESC,
-    'table': INCLUDE_DESC | INCLUDE_NAME,
-    'link': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'helpballoon': NAME_FROM_SUBTREE_RULE,
-    'list': INCLUDE_DESC | INCLUDE_NAME,
-    'listitem': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'outline': INCLUDE_DESC,
-    'outlineitem': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'pagetab': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'graphic': INCLUDE_DESC,
-    'switch': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'pushbutton': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'checkbutton': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'radiobutton': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'buttondropdown': NAME_FROM_SUBTREE_RULE,
-    'combobox': INCLUDE_DESC | INCLUDE_VALUE,
-    'droplist': INCLUDE_DESC,
-    'progressbar': INCLUDE_DESC | INCLUDE_VALUE,
-    'slider': INCLUDE_DESC | INCLUDE_VALUE,
-    'spinbutton': INCLUDE_DESC | INCLUDE_VALUE,
-    'diagram': INCLUDE_DESC,
-    'animation': INCLUDE_DESC,
-    'equation': INCLUDE_DESC,
-    'buttonmenu': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'buttondropdowngrid': NAME_FROM_SUBTREE_RULE,
-    'pagetablist': INCLUDE_DESC,
-    'canvas': INCLUDE_DESC,
-    'check menu item': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'label': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'password text': INCLUDE_DESC,
-    'popup menu': INCLUDE_DESC,
-    'radio menu item': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'table column header': NAME_FROM_SUBTREE_RULE,
-    'table row header': NAME_FROM_SUBTREE_RULE,
-    'tear off menu item': NAME_FROM_SUBTREE_RULE,
-    'toggle button': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'parent menuitem': NAME_FROM_SUBTREE_RULE,
-    'header': INCLUDE_DESC,
-    'footer': INCLUDE_DESC,
-    'entry': INCLUDE_DESC | INCLUDE_NAME | INCLUDE_VALUE,
-    'caption': INCLUDE_DESC,
-    'document frame': INCLUDE_DESC,
-    'heading': INCLUDE_DESC,
-    'calendar': INCLUDE_DESC | INCLUDE_NAME,
-    'combobox option': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'listbox option': INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
-    'listbox rich option': NAME_FROM_SUBTREE_RULE,
-    'gridcell': NAME_FROM_SUBTREE_RULE,
-    'check rich option': NAME_FROM_SUBTREE_RULE,
-    'term': NAME_FROM_SUBTREE_RULE,
-    'definition': NAME_FROM_SUBTREE_RULE,
-    'key': NAME_FROM_SUBTREE_RULE,
-    'image map': INCLUDE_DESC,
-    'option': INCLUDE_DESC,
-    'listbox': INCLUDE_DESC,
-    'definitionlist': INCLUDE_DESC | INCLUDE_NAME,
-    'dialog': INCLUDE_DESC | INCLUDE_NAME,
-    'chrome window': IGNORE_EXPLICIT_NAME,
-    'app root': IGNORE_EXPLICIT_NAME,
-    'statusbar': NAME_FROM_SUBTREE_RULE,
-    'mathml table': INCLUDE_DESC | INCLUDE_NAME,
-    'mathml labeled row': NAME_FROM_SUBTREE_RULE,
-    'mathml table row': NAME_FROM_SUBTREE_RULE,
-    'mathml cell': INCLUDE_DESC | INCLUDE_NAME,
-    'mathml fraction': INCLUDE_DESC,
-    'mathml square root': INCLUDE_DESC,
-    'mathml root': INCLUDE_DESC,
-    'mathml enclosed': INCLUDE_DESC,
-    'mathml sub': INCLUDE_DESC,
-    'mathml sup': INCLUDE_DESC,
-    'mathml sub sup': INCLUDE_DESC,
-    'mathml under': INCLUDE_DESC,
-    'mathml over': INCLUDE_DESC,
-    'mathml under over': INCLUDE_DESC,
-    'mathml multiscripts': INCLUDE_DESC,
-    'mathml identifier': INCLUDE_DESC,
-    'mathml number': INCLUDE_DESC,
-    'mathml operator': INCLUDE_DESC,
-    'mathml text': INCLUDE_DESC,
-    'mathml string literal': INCLUDE_DESC,
-    'mathml row': INCLUDE_DESC,
-    'mathml style': INCLUDE_DESC,
-    'mathml error': INCLUDE_DESC },
+    "menubar": INCLUDE_DESC,
+    "scrollbar": INCLUDE_DESC,
+    "grip": INCLUDE_DESC,
+    "alert": INCLUDE_DESC | INCLUDE_NAME,
+    "menupopup": INCLUDE_DESC,
+    "menuitem": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "tooltip": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "columnheader": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "rowheader": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "column": NAME_FROM_SUBTREE_RULE,
+    "row": NAME_FROM_SUBTREE_RULE,
+    "cell": INCLUDE_DESC | INCLUDE_NAME,
+    "application": INCLUDE_NAME,
+    "document": INCLUDE_NAME,
+    "grouping": INCLUDE_DESC | INCLUDE_NAME,
+    "toolbar": INCLUDE_DESC,
+    "table": INCLUDE_DESC | INCLUDE_NAME,
+    "link": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "helpballoon": NAME_FROM_SUBTREE_RULE,
+    "list": INCLUDE_DESC | INCLUDE_NAME,
+    "listitem": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "outline": INCLUDE_DESC,
+    "outlineitem": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "pagetab": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "graphic": INCLUDE_DESC,
+    "switch": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "pushbutton": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "checkbutton": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "radiobutton": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "buttondropdown": NAME_FROM_SUBTREE_RULE,
+    "combobox": INCLUDE_DESC | INCLUDE_VALUE,
+    "droplist": INCLUDE_DESC,
+    "progressbar": INCLUDE_DESC | INCLUDE_VALUE,
+    "slider": INCLUDE_DESC | INCLUDE_VALUE,
+    "spinbutton": INCLUDE_DESC | INCLUDE_VALUE,
+    "diagram": INCLUDE_DESC,
+    "animation": INCLUDE_DESC,
+    "equation": INCLUDE_DESC,
+    "buttonmenu": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "buttondropdowngrid": NAME_FROM_SUBTREE_RULE,
+    "pagetablist": INCLUDE_DESC,
+    "canvas": INCLUDE_DESC,
+    "check menu item": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "label": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "password text": INCLUDE_DESC,
+    "popup menu": INCLUDE_DESC,
+    "radio menu item": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "table column header": NAME_FROM_SUBTREE_RULE,
+    "table row header": NAME_FROM_SUBTREE_RULE,
+    "tear off menu item": NAME_FROM_SUBTREE_RULE,
+    "toggle button": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "parent menuitem": NAME_FROM_SUBTREE_RULE,
+    "header": INCLUDE_DESC,
+    "footer": INCLUDE_DESC,
+    "entry": INCLUDE_DESC | INCLUDE_NAME | INCLUDE_VALUE,
+    "caption": INCLUDE_DESC,
+    "document frame": INCLUDE_DESC,
+    "heading": INCLUDE_DESC,
+    "calendar": INCLUDE_DESC | INCLUDE_NAME,
+    "combobox option": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "listbox option": INCLUDE_DESC | NAME_FROM_SUBTREE_RULE,
+    "listbox rich option": NAME_FROM_SUBTREE_RULE,
+    "gridcell": NAME_FROM_SUBTREE_RULE,
+    "check rich option": NAME_FROM_SUBTREE_RULE,
+    "term": NAME_FROM_SUBTREE_RULE,
+    "definition": NAME_FROM_SUBTREE_RULE,
+    "key": NAME_FROM_SUBTREE_RULE,
+    "image map": INCLUDE_DESC,
+    "option": INCLUDE_DESC,
+    "listbox": INCLUDE_DESC,
+    "definitionlist": INCLUDE_DESC | INCLUDE_NAME,
+    "dialog": INCLUDE_DESC | INCLUDE_NAME,
+    "chrome window": IGNORE_EXPLICIT_NAME,
+    "app root": IGNORE_EXPLICIT_NAME,
+    "statusbar": NAME_FROM_SUBTREE_RULE,
+    "mathml table": INCLUDE_DESC | INCLUDE_NAME,
+    "mathml labeled row": NAME_FROM_SUBTREE_RULE,
+    "mathml table row": NAME_FROM_SUBTREE_RULE,
+    "mathml cell": INCLUDE_DESC | INCLUDE_NAME,
+    "mathml fraction": INCLUDE_DESC,
+    "mathml square root": INCLUDE_DESC,
+    "mathml root": INCLUDE_DESC,
+    "mathml enclosed": INCLUDE_DESC,
+    "mathml sub": INCLUDE_DESC,
+    "mathml sup": INCLUDE_DESC,
+    "mathml sub sup": INCLUDE_DESC,
+    "mathml under": INCLUDE_DESC,
+    "mathml over": INCLUDE_DESC,
+    "mathml under over": INCLUDE_DESC,
+    "mathml multiscripts": INCLUDE_DESC,
+    "mathml identifier": INCLUDE_DESC,
+    "mathml number": INCLUDE_DESC,
+    "mathml operator": INCLUDE_DESC,
+    "mathml text": INCLUDE_DESC,
+    "mathml string literal": INCLUDE_DESC,
+    "mathml row": INCLUDE_DESC,
+    "mathml style": INCLUDE_DESC,
+    "mathml error": INCLUDE_DESC },
 
   mathmlRolesSet: new Set([
     Roles.MATHML_MATH,
     Roles.MATHML_IDENTIFIER,
     Roles.MATHML_NUMBER,
     Roles.MATHML_OPERATOR,
     Roles.MATHML_TEXT,
     Roles.MATHML_STRING_LITERAL,
@@ -459,17 +459,17 @@ var OutputGenerator = {
 
         if (aFlags & INCLUDE_DESC) {
           this._addState(output, aState, aRoleStr);
           this._addType(output, aAccessible, aRoleStr);
           this._addRole(output, aAccessible, aRoleStr);
         }
 
         if (aFlags & INCLUDE_VALUE && aAccessible.value.trim()) {
-          output[this.outputOrder === OUTPUT_DESC_FIRST ? 'push' : 'unshift'](
+          output[this.outputOrder === OUTPUT_DESC_FIRST ? "push" : "unshift"](
             aAccessible.value);
         }
 
         this._addName(output, aAccessible, aFlags);
         this._addLandmark(output, aAccessible);
 
         return output;
       },
@@ -481,30 +481,30 @@ var OutputGenerator = {
         // we don't need the context.
         return [];
       }
 
       return this.objectOutputFunctions.defaultFunc.apply(this, arguments);
     },
 
     entry: function entry(aAccessible, aRoleStr, aState, aFlags) {
-      let rolestr = aState.contains(States.MULTI_LINE) ? 'textarea' : 'entry';
+      let rolestr = aState.contains(States.MULTI_LINE) ? "textarea" : "entry";
       return this.objectOutputFunctions.defaultFunc.apply(
         this, [aAccessible, rolestr, aState, aFlags]);
     },
 
     pagetab: function pagetab(aAccessible, aRoleStr, aState, aFlags) {
       let itemno = {};
       let itemof = {};
       aAccessible.groupPosition({}, itemof, itemno);
       let output = [];
       this._addState(output, aState);
       this._addRole(output, aAccessible, aRoleStr);
       output.push({
-        string: 'objItemOfN',
+        string: "objItemOfN",
         args: [itemno.value, itemof.value]
       });
 
       this._addName(output, aAccessible, aFlags);
       this._addLandmark(output, aAccessible);
 
       return output;
     },
@@ -520,20 +520,20 @@ var OutputGenerator = {
       } finally {
         // Check if it's a layout table, and bail out if true.
         // We don't want to speak any table information for layout tables.
         if (table.isProbablyForLayout()) {
           return output;
         }
         this._addRole(output, aAccessible, aRoleStr);
         output.push.call(output, {
-          string: this._getOutputName('tblColumnInfo'),
+          string: this._getOutputName("tblColumnInfo"),
           count: table.columnCount
         }, {
-          string: this._getOutputName('tblRowInfo'),
+          string: this._getOutputName("tblRowInfo"),
           count: table.rowCount
         });
         this._addName(output, aAccessible, aFlags);
         this._addLandmark(output, aAccessible);
         return output;
       }
     },
 
@@ -579,107 +579,107 @@ var OutputGenerator = {
  * For example {@link genForAction} might return ['button', 'clicked'] for a
  * clicked event. Speaking only 'clicked' makes sense. Speaking 'button' does
  * not.
  */
 this.UtteranceGenerator = {  // jshint ignore:line
   __proto__: OutputGenerator, // jshint ignore:line
 
   gActionMap: {
-    jump: 'jumpAction',
-    press: 'pressAction',
-    check: 'checkAction',
-    uncheck: 'uncheckAction',
-    on: 'onAction',
-    off: 'offAction',
-    select: 'selectAction',
-    unselect: 'unselectAction',
-    open: 'openAction',
-    close: 'closeAction',
-    switch: 'switchAction',
-    click: 'clickAction',
-    collapse: 'collapseAction',
-    expand: 'expandAction',
-    activate: 'activateAction',
-    cycle: 'cycleAction'
+    jump: "jumpAction",
+    press: "pressAction",
+    check: "checkAction",
+    uncheck: "uncheckAction",
+    on: "onAction",
+    off: "offAction",
+    select: "selectAction",
+    unselect: "unselectAction",
+    open: "openAction",
+    close: "closeAction",
+    switch: "switchAction",
+    click: "clickAction",
+    collapse: "collapseAction",
+    expand: "expandAction",
+    activate: "activateAction",
+    cycle: "cycleAction"
   },
 
   //TODO: May become more verbose in the future.
   genForAction: function genForAction(aObject, aActionName) {
     return [{string: this.gActionMap[aActionName]}];
   },
 
   genForLiveRegion:
     function genForLiveRegion(aContext, aIsHide, aModifiedText) {
       let utterance = [];
       if (aIsHide) {
-        utterance.push({string: 'hidden'});
+        utterance.push({string: "hidden"});
       }
       return utterance.concat(aModifiedText || this.genForContext(aContext));
     },
 
   genForAnnouncement: function genForAnnouncement(aAnnouncement) {
     return [{
       string: aAnnouncement
     }];
   },
 
   genForTabStateChange: function genForTabStateChange(aObject, aTabState) {
     switch (aTabState) {
-      case 'newtab':
-        return [{string: 'tabNew'}];
-      case 'loading':
-        return [{string: 'tabLoading'}];
-      case 'loaded':
-        return [aObject.name, {string: 'tabLoaded'}];
-      case 'loadstopped':
-        return [{string: 'tabLoadStopped'}];
-      case 'reload':
-        return [{string: 'tabReload'}];
+      case "newtab":
+        return [{string: "tabNew"}];
+      case "loading":
+        return [{string: "tabLoading"}];
+      case "loaded":
+        return [aObject.name, {string: "tabLoaded"}];
+      case "loadstopped":
+        return [{string: "tabLoadStopped"}];
+      case "reload":
+        return [{string: "tabReload"}];
       default:
         return [];
     }
   },
 
   genForEditingMode: function genForEditingMode(aIsEditing) {
-    return [{string: aIsEditing ? 'editingMode' : 'navigationMode'}];
+    return [{string: aIsEditing ? "editingMode" : "navigationMode"}];
   },
 
   objectOutputFunctions: {
 
     __proto__: OutputGenerator.objectOutputFunctions, // jshint ignore:line
 
     defaultFunc: function defaultFunc() {
       return this.objectOutputFunctions._generateBaseOutput.apply(
         this, arguments);
     },
 
     heading: function heading(aAccessible, aRoleStr, aState, aFlags) {
       let level = {};
       aAccessible.groupPosition(level, {}, {});
-      let utterance = [{string: 'headingLevel', args: [level.value]}];
+      let utterance = [{string: "headingLevel", args: [level.value]}];
 
       this._addName(utterance, aAccessible, aFlags);
       this._addLandmark(utterance, aAccessible);
 
       return utterance;
     },
 
     listitem: function listitem(aAccessible, aRoleStr, aState, aFlags) {
       let itemno = {};
       let itemof = {};
       aAccessible.groupPosition({}, itemof, itemno);
       let utterance = [];
       if (itemno.value == 1) {
         // Start of list
-        utterance.push({string: 'listStart'});
+        utterance.push({string: "listStart"});
       }
       else if (itemno.value == itemof.value) {
         // last item
-        utterance.push({string: 'listEnd'});
+        utterance.push({string: "listEnd"});
       }
 
       this._addName(utterance, aAccessible, aFlags);
       this._addLandmark(utterance, aAccessible);
 
       return utterance;
     },
 
@@ -720,22 +720,22 @@ this.UtteranceGenerator = {  // jshint i
           }
         };
         let addHeaders = function addHeaders(aUtterance, aHeaders) {
           if (aHeaders.length > 0) {
             aUtterance.push.apply(aUtterance, aHeaders);
           }
         };
 
-        addCellChanged(utterance, cell.columnChanged, 'columnInfo',
+        addCellChanged(utterance, cell.columnChanged, "columnInfo",
           cell.columnIndex);
-        addCellChanged(utterance, cell.rowChanged, 'rowInfo', cell.rowIndex);
+        addCellChanged(utterance, cell.rowChanged, "rowInfo", cell.rowIndex);
 
-        addExtent(utterance, cell.columnExtent, 'spansColumns');
-        addExtent(utterance, cell.rowExtent, 'spansRows');
+        addExtent(utterance, cell.columnExtent, "spansColumns");
+        addExtent(utterance, cell.rowExtent, "spansRows");
 
         addHeaders(utterance, cell.columnHeaders);
         addHeaders(utterance, cell.rowHeaders);
       }
 
       this._addName(utterance, aAccessible, aFlags);
       this._addLandmark(utterance, aAccessible);
 
@@ -769,72 +769,72 @@ this.UtteranceGenerator = {  // jshint i
     } else {
       aOutput.push({string: this._getOutputName(aRoleStr)});
     }
   },
 
   _addState: function _addState(aOutput, aState, aRoleStr) {
 
     if (aState.contains(States.UNAVAILABLE)) {
-      aOutput.push({string: 'stateUnavailable'});
+      aOutput.push({string: "stateUnavailable"});
     }
 
     if (aState.contains(States.READONLY)) {
-      aOutput.push({string: 'stateReadonly'});
+      aOutput.push({string: "stateReadonly"});
     }
 
     // Don't utter this in Jelly Bean, we let TalkBack do it for us there.
     // This is because we expose the checked information on the node itself.
     // XXX: this means the checked state is always appended to the end,
     // regardless of the utterance ordering preference.
-    if ((Utils.AndroidSdkVersion < 16 || Utils.MozBuildApp === 'browser') &&
+    if ((Utils.AndroidSdkVersion < 16 || Utils.MozBuildApp === "browser") &&
       aState.contains(States.CHECKABLE)) {
       let checked = aState.contains(States.CHECKED);
       let statetr;
-      if (aRoleStr === 'switch') {
-        statetr = checked ? 'stateOn' : 'stateOff';
+      if (aRoleStr === "switch") {
+        statetr = checked ? "stateOn" : "stateOff";
       } else {
-        statetr = checked ? 'stateChecked' : 'stateNotChecked';
+        statetr = checked ? "stateChecked" : "stateNotChecked";
       }
       aOutput.push({string: statetr});
     }
 
     if (aState.contains(States.PRESSED)) {
-      aOutput.push({string: 'statePressed'});
+      aOutput.push({string: "statePressed"});
     }
 
     if (aState.contains(States.EXPANDABLE)) {
       let statetr = aState.contains(States.EXPANDED) ?
-        'stateExpanded' : 'stateCollapsed';
+        "stateExpanded" : "stateCollapsed";
       aOutput.push({string: statetr});
     }
 
     if (aState.contains(States.REQUIRED)) {
-      aOutput.push({string: 'stateRequired'});
+      aOutput.push({string: "stateRequired"});
     }
 
     if (aState.contains(States.TRAVERSED)) {
-      aOutput.push({string: 'stateTraversed'});
+      aOutput.push({string: "stateTraversed"});
     }
 
     if (aState.contains(States.HASPOPUP)) {
-      aOutput.push({string: 'stateHasPopup'});
+      aOutput.push({string: "stateHasPopup"});
     }
 
     if (aState.contains(States.SELECTED)) {
-      aOutput.push({string: 'stateSelected'});
+      aOutput.push({string: "stateSelected"});
     }
   },
 
   _getListUtterance:
     function _getListUtterance(aAccessible, aRoleStr, aFlags, aItemCount) {
       let utterance = [];
       this._addRole(utterance, aAccessible, aRoleStr);
       utterance.push({
-        string: this._getOutputName('listItemsCount'),
+        string: this._getOutputName("listItemsCount"),
         count: aItemCount
       });
 
       this._addName(utterance, aAccessible, aFlags);
       this._addLandmark(utterance, aAccessible);
 
       return utterance;
     }
@@ -846,32 +846,32 @@ this.BrailleGenerator = {  // jshint ign
   genForContext: function genForContext(aContext) {
     let output = OutputGenerator.genForContext.apply(this, arguments);
 
     let acc = aContext.accessible;
 
     // add the static text indicating a list item; do this for both listitems or
     // direct first children of listitems, because these are both common
     // browsing scenarios
-    let addListitemIndicator = function addListitemIndicator(indicator = '*') {
+    let addListitemIndicator = function addListitemIndicator(indicator = "*") {
       output.unshift(indicator);
     };
 
     if (acc.indexInParent === 1 &&
         acc.parent.role == Roles.LISTITEM &&
         acc.previousSibling.role == Roles.STATICTEXT) {
       if (acc.parent.parent && acc.parent.parent.DOMNode &&
-          acc.parent.parent.DOMNode.nodeName == 'UL') {
+          acc.parent.parent.DOMNode.nodeName == "UL") {
         addListitemIndicator();
       } else {
         addListitemIndicator(acc.previousSibling.name.trim());
       }
     } else if (acc.role == Roles.LISTITEM && acc.firstChild &&
                acc.firstChild.role == Roles.STATICTEXT) {
-      if (acc.parent.DOMNode.nodeName == 'UL') {
+      if (acc.parent.DOMNode.nodeName == "UL") {
         addListitemIndicator();
       } else {
         addListitemIndicator(acc.firstChild.name.trim());
       }
     }
 
     return output;
   },
@@ -900,17 +900,17 @@ this.BrailleGenerator = {  // jshint ign
       if (cell) {
         let addHeaders = function addHeaders(aBraille, aHeaders) {
           if (aHeaders.length > 0) {
             aBraille.push.apply(aBraille, aHeaders);
           }
         };
 
         braille.push({
-          string: this._getOutputName('cellInfo'),
+          string: this._getOutputName("cellInfo"),
           args: [cell.columnIndex + 1, cell.rowIndex + 1]
         });
 
         addHeaders(braille, cell.columnHeaders);
         addHeaders(braille, cell.rowHeaders);
       }
 
       this._addName(braille, aAccessible, aFlags);
@@ -967,36 +967,36 @@ this.BrailleGenerator = {  // jshint ign
     if (aContext.accessible.parent.role == Roles.LINK) {
       return [aContext.accessible.parent];
     }
 
     return [];
   },
 
   _getOutputName: function _getOutputName(aName) {
-    return OutputGenerator._getOutputName(aName) + 'Abbr';
+    return OutputGenerator._getOutputName(aName) + "Abbr";
   },
 
   _addRole: function _addRole(aBraille, aAccessible, aRoleStr) {
     if (this.mathmlRolesSet.has(aAccessible.role)) {
       this._addMathRoles(aBraille, aAccessible, aRoleStr);
     } else {
       aBraille.push({string: this._getOutputName(aRoleStr)});
     }
   },
 
   _addState: function _addState(aBraille, aState, aRoleStr) {
     if (aState.contains(States.CHECKABLE)) {
       aBraille.push({
         string: aState.contains(States.CHECKED) ?
-          this._getOutputName('stateChecked') :
-          this._getOutputName('stateUnchecked')
+          this._getOutputName("stateChecked") :
+          this._getOutputName("stateUnchecked")
       });
     }
-    if (aRoleStr === 'toggle button') {
+    if (aRoleStr === "toggle button") {
       aBraille.push({
         string: aState.contains(States.PRESSED) ?
-          this._getOutputName('statePressed') :
-          this._getOutputName('stateUnpressed')
+          this._getOutputName("statePressed") :
+          this._getOutputName("stateUnpressed")
       });
     }
   }
 };
--- a/accessible/jsat/PointerAdapter.jsm
+++ b/accessible/jsat/PointerAdapter.jsm
@@ -1,130 +1,130 @@
 /* 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/. */
 
 /* exported PointerRelay, PointerAdapter */
 
-'use strict';
+"use strict";
 
 const Ci = Components.interfaces;
 const Cu = Components.utils;
 
-this.EXPORTED_SYMBOLS = ['PointerRelay', 'PointerAdapter']; // jshint ignore:line
+this.EXPORTED_SYMBOLS = ["PointerRelay", "PointerAdapter"]; // jshint ignore:line
 
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 
-XPCOMUtils.defineLazyModuleGetter(this, 'Utils', // jshint ignore:line
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Logger', // jshint ignore:line
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'GestureSettings', // jshint ignore:line
-  'resource://gre/modules/accessibility/Gestures.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'GestureTracker', // jshint ignore:line
-  'resource://gre/modules/accessibility/Gestures.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, "Utils", // jshint ignore:line
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Logger", // jshint ignore:line
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "GestureSettings", // jshint ignore:line
+  "resource://gre/modules/accessibility/Gestures.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "GestureTracker", // jshint ignore:line
+  "resource://gre/modules/accessibility/Gestures.jsm");
 
 // The virtual touch ID generated by a mouse event.
-const MOUSE_ID = 'mouse';
+const MOUSE_ID = "mouse";
 // Synthesized touch ID.
 const SYNTH_ID = -1;
 
 var PointerRelay = { // jshint ignore:line
   /**
    * A mapping of events we should be intercepting. Entries with a value of
    * |true| are used for compiling high-level gesture events. Entries with a
    * value of |false| are cancelled and do not propogate to content.
    */
   get _eventsOfInterest() {
     delete this._eventsOfInterest;
 
     switch (Utils.widgetToolkit) {
-      case 'android':
+      case "android":
         this._eventsOfInterest = {
-          'touchstart': true,
-          'touchmove': true,
-          'touchend': true };
+          "touchstart": true,
+          "touchmove": true,
+          "touchend": true };
         break;
 
-      case 'gonk':
+      case "gonk":
         this._eventsOfInterest = {
-          'touchstart': true,
-          'touchmove': true,
-          'touchend': true,
-          'mousedown': false,
-          'mousemove': false,
-          'mouseup': false,
-          'click': false };
+          "touchstart": true,
+          "touchmove": true,
+          "touchend": true,
+          "mousedown": false,
+          "mousemove": false,
+          "mouseup": false,
+          "click": false };
         break;
 
       default:
         // Desktop.
         this._eventsOfInterest = {
-          'mousemove': true,
-          'mousedown': true,
-          'mouseup': true,
-          'click': false
+          "mousemove": true,
+          "mousedown": true,
+          "mouseup": true,
+          "click": false
         };
-        if ('ontouchstart' in Utils.win) {
-          for (let eventType of ['touchstart', 'touchmove', 'touchend']) {
+        if ("ontouchstart" in Utils.win) {
+          for (let eventType of ["touchstart", "touchmove", "touchend"]) {
             this._eventsOfInterest[eventType] = true;
           }
         }
         break;
     }
 
     return this._eventsOfInterest;
   },
 
   _eventMap: {
-    'touchstart': 'pointerdown',
-    'mousedown': 'pointerdown',
-    'touchmove': 'pointermove',
-    'mousemove': 'pointermove',
-    'touchend': 'pointerup',
-    'mouseup': 'pointerup'
+    "touchstart": "pointerdown",
+    "mousedown": "pointerdown",
+    "touchmove": "pointermove",
+    "mousemove": "pointermove",
+    "touchend": "pointerup",
+    "mouseup": "pointerup"
   },
 
   start: function PointerRelay_start(aOnPointerEvent) {
-    Logger.debug('PointerRelay.start');
+    Logger.debug("PointerRelay.start");
     this.onPointerEvent = aOnPointerEvent;
     for (let eventType in this._eventsOfInterest) {
       Utils.win.addEventListener(eventType, this, true, true);
     }
   },
 
   stop: function PointerRelay_stop() {
-    Logger.debug('PointerRelay.stop');
+    Logger.debug("PointerRelay.stop");
     delete this.lastPointerMove;
     delete this.onPointerEvent;
     for (let eventType in this._eventsOfInterest) {
       Utils.win.removeEventListener(eventType, this, true, true);
     }
   },
 
   handleEvent: function PointerRelay_handleEvent(aEvent) {
     // Don't bother with chrome mouse events.
-    if (Utils.MozBuildApp === 'browser' &&
+    if (Utils.MozBuildApp === "browser" &&
       aEvent.view.top instanceof Ci.nsIDOMChromeWindow) {
       return;
     }
     if (aEvent.mozInputSource === Ci.nsIDOMMouseEvent.MOZ_SOURCE_UNKNOWN ||
         aEvent.isSynthesized) {
       // Ignore events that are scripted or clicks from the a11y API.
       return;
     }
 
     let changedTouches = aEvent.changedTouches || [{
       identifier: MOUSE_ID,
       screenX: aEvent.screenX,
       screenY: aEvent.screenY,
       target: aEvent.target
     }];
 
-    if (Utils.widgetToolkit === 'android' &&
+    if (Utils.widgetToolkit === "android" &&
       changedTouches.length === 1 && changedTouches[0].identifier === 1) {
       return;
     }
 
     if (changedTouches.length === 1 &&
         changedTouches[0].identifier === SYNTH_ID) {
       return;
     }
@@ -149,23 +149,23 @@ var PointerRelay = { // jshint ignore:li
         }
       )
     });
   }
 };
 
 this.PointerAdapter = { // jshint ignore:line
   start: function PointerAdapter_start() {
-    Logger.debug('PointerAdapter.start');
+    Logger.debug("PointerAdapter.start");
     GestureTracker.reset();
     PointerRelay.start(this.handleEvent);
   },
 
   stop: function PointerAdapter_stop() {
-    Logger.debug('PointerAdapter.stop');
+    Logger.debug("PointerAdapter.stop");
     PointerRelay.stop();
     GestureTracker.reset();
   },
 
   handleEvent: function PointerAdapter_handleEvent(aDetail) {
     let timeStamp = Date.now();
     GestureTracker.handle(aDetail, timeStamp);
   }
--- a/accessible/jsat/Presentation.jsm
+++ b/accessible/jsat/Presentation.jsm
@@ -1,46 +1,46 @@
 /* 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/. */
 
 /* exported Presentation */
 
-'use strict';
+"use strict";
 
 const {utils: Cu, interfaces: Ci} = Components;
 
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
-Cu.import('resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Logger', // jshint ignore:line
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'PivotContext', // jshint ignore:line
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'UtteranceGenerator', // jshint ignore:line
-  'resource://gre/modules/accessibility/OutputGenerator.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'BrailleGenerator', // jshint ignore:line
-  'resource://gre/modules/accessibility/OutputGenerator.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Roles', // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'States', // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Logger", // jshint ignore:line
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PivotContext", // jshint ignore:line
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "UtteranceGenerator", // jshint ignore:line
+  "resource://gre/modules/accessibility/OutputGenerator.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "BrailleGenerator", // jshint ignore:line
+  "resource://gre/modules/accessibility/OutputGenerator.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Roles", // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "States", // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
 
-this.EXPORTED_SYMBOLS = ['Presentation']; // jshint ignore:line
+this.EXPORTED_SYMBOLS = ["Presentation"]; // jshint ignore:line
 
 /**
  * The interface for all presenter classes. A presenter could be, for example,
  * a speech output module, or a visual cursor indicator.
  */
 function Presenter() {}
 
 Presenter.prototype = {
   /**
    * The type of presenter. Used for matching it with the appropriate output method.
    */
-  type: 'Base',
+  type: "Base",
 
   /**
    * The virtual cursor's position changed.
    * @param {PivotContext} aContext the context object for the new pivot
    *   position.
    * @param {int} aReason the reason for the pivot change.
    *   See nsIAccessiblePivot.
    * @param {bool} aIsFromUserInput the pivot change was invoked by the user
@@ -140,17 +140,17 @@ Presenter.prototype = {
 
 /**
  * Visual presenter. Draws a box around the virtual cursor's position.
  */
 function VisualPresenter() {}
 
 VisualPresenter.prototype = Object.create(Presenter.prototype);
 
-VisualPresenter.prototype.type = 'Visual';
+VisualPresenter.prototype.type = "Visual";
 
 /**
  * The padding in pixels between the object and the highlight border.
  */
 VisualPresenter.prototype.BORDER_PADDING = 2;
 
 VisualPresenter.prototype.viewportChanged =
   function VisualPresenter_viewportChanged(aWindow, aCurrentContext) {
@@ -163,17 +163,17 @@ VisualPresenter.prototype.viewportChange
     let end = aCurrentContext.endOffset;
     if (Utils.isAliveAndVisible(currentAcc)) {
       let bounds = (start === -1 && end === -1) ? Utils.getBounds(currentAcc) :
                    Utils.getTextBounds(currentAcc, start, end);
 
       return {
         type: this.type,
         details: {
-          eventType: 'viewport-change',
+          eventType: "viewport-change",
           bounds: bounds,
           padding: this.BORDER_PADDING
         }
       };
     }
 
     return null;
   };
@@ -192,49 +192,49 @@ VisualPresenter.prototype.pivotChanged =
       let bounds = (aContext.startOffset === -1 && aContext.endOffset === -1) ?
             aContext.bounds : Utils.getTextBounds(aContext.accessibleForBounds,
                                                   aContext.startOffset,
                                                   aContext.endOffset);
 
       return {
         type: this.type,
         details: {
-          eventType: 'vc-change',
+          eventType: "vc-change",
           bounds: bounds,
           padding: this.BORDER_PADDING
         }
       };
     } catch (e) {
-      Logger.logException(e, 'Failed to get bounds');
+      Logger.logException(e, "Failed to get bounds");
       return null;
     }
   };
 
 VisualPresenter.prototype.tabSelected =
   function VisualPresenter_tabSelected(aDocContext, aVCContext) {
     return this.pivotChanged(aVCContext, Ci.nsIAccessiblePivot.REASON_NONE);
   };
 
 VisualPresenter.prototype.tabStateChanged =
   function VisualPresenter_tabStateChanged(aDocObj, aPageState) {
-    if (aPageState == 'newdoc') {
-      return {type: this.type, details: {eventType: 'tabstate-change'}};
+    if (aPageState == "newdoc") {
+      return {type: this.type, details: {eventType: "tabstate-change"}};
     }
 
     return null;
   };
 
 /**
  * Android presenter. Fires Android a11y events.
  */
 function AndroidPresenter() {}
 
 AndroidPresenter.prototype = Object.create(Presenter.prototype);
 
-AndroidPresenter.prototype.type = 'Android';
+AndroidPresenter.prototype.type = "Android";
 
 // Android AccessibilityEvent type constants.
 AndroidPresenter.prototype.ANDROID_VIEW_CLICKED = 0x01;
 AndroidPresenter.prototype.ANDROID_VIEW_LONG_CLICKED = 0x02;
 AndroidPresenter.prototype.ANDROID_VIEW_SELECTED = 0x04;
 AndroidPresenter.prototype.ANDROID_VIEW_FOCUSED = 0x08;
 AndroidPresenter.prototype.ANDROID_VIEW_TEXT_CHANGED = 0x10;
 AndroidPresenter.prototype.ANDROID_WINDOW_STATE_CHANGED = 0x20;
@@ -436,17 +436,17 @@ AndroidPresenter.prototype.viewportChang
 
 AndroidPresenter.prototype.editingModeChanged =
   function AndroidPresenter_editingModeChanged(aIsEditing) {
     return this.announce(UtteranceGenerator.genForEditingMode(aIsEditing));
   };
 
 AndroidPresenter.prototype.announce =
   function AndroidPresenter_announce(aAnnouncement) {
-    let localizedAnnouncement = Utils.localize(aAnnouncement).join(' ');
+    let localizedAnnouncement = Utils.localize(aAnnouncement).join(" ");
     return {
       type: this.type,
       details: [{
         eventType: (Utils.AndroidSdkVersion >= 16) ?
           this.ANDROID_ANNOUNCEMENT : this.ANDROID_VIEW_TEXT_CHANGED,
         text: [localizedAnnouncement],
         addedCount: localizedAnnouncement.length,
         removedCount: 0,
@@ -464,60 +464,60 @@ AndroidPresenter.prototype.liveRegion =
 
 AndroidPresenter.prototype.noMove =
   function AndroidPresenter_noMove(aMoveMethod) {
     return {
       type: this.type,
       details: [
       { eventType: this.ANDROID_VIEW_ACCESSIBILITY_FOCUSED,
         exitView: aMoveMethod,
-        text: ['']
+        text: [""]
       }]
     };
   };
 
 /**
  * A B2G presenter for Gaia.
  */
 function B2GPresenter() {}
 
 B2GPresenter.prototype = Object.create(Presenter.prototype);
 
-B2GPresenter.prototype.type = 'B2G';
+B2GPresenter.prototype.type = "B2G";
 
 B2GPresenter.prototype.keyboardEchoSetting =
-  new PrefCache('accessibility.accessfu.keyboard_echo');
+  new PrefCache("accessibility.accessfu.keyboard_echo");
 B2GPresenter.prototype.NO_ECHO = 0;
 B2GPresenter.prototype.CHARACTER_ECHO = 1;
 B2GPresenter.prototype.WORD_ECHO = 2;
 B2GPresenter.prototype.CHARACTER_AND_WORD_ECHO = 3;
 
 /**
  * A pattern used for haptic feedback.
  * @type {Array}
  */
 B2GPresenter.prototype.PIVOT_CHANGE_HAPTIC_PATTERN = [40];
 
 /**
  * Pivot move reasons.
  * @type {Array}
  */
-B2GPresenter.prototype.pivotChangedReasons = ['none', 'next', 'prev', 'first',
-                                              'last', 'text', 'point'];
+B2GPresenter.prototype.pivotChangedReasons = ["none", "next", "prev", "first",
+                                              "last", "text", "point"];
 
 B2GPresenter.prototype.pivotChanged =
   function B2GPresenter_pivotChanged(aContext, aReason, aIsUserInput) {
     if (!aContext.accessible) {
       return null;
     }
 
     return {
       type: this.type,
       details: {
-        eventType: 'vc-change',
+        eventType: "vc-change",
         data: UtteranceGenerator.genForContext(aContext),
         options: {
           pattern: this.PIVOT_CHANGE_HAPTIC_PATTERN,
           isKey: Utils.isActivatableOnFingerUp(aContext.accessible),
           reason: this.pivotChangedReasons[aReason],
           isUserInput: aIsUserInput,
           hints: aContext.interactionHints
         }
@@ -525,17 +525,17 @@ B2GPresenter.prototype.pivotChanged =
     };
   };
 
 B2GPresenter.prototype.nameChanged =
   function B2GPresenter_nameChanged(aAccessible, aIsPolite = true) {
     return {
       type: this.type,
       details: {
-        eventType: 'name-change',
+        eventType: "name-change",
         data: aAccessible.name,
         options: {enqueue: aIsPolite}
       }
     };
   };
 
 B2GPresenter.prototype.valueChanged =
   function B2GPresenter_valueChanged(aAccessible, aIsPolite = true) {
@@ -543,27 +543,27 @@ B2GPresenter.prototype.valueChanged =
     // the editable value changes are handled in the text changed presenter
     if (Utils.getState(aAccessible).contains(States.EDITABLE)) {
       return null;
     }
 
     return {
       type: this.type,
       details: {
-        eventType: 'value-change',
+        eventType: "value-change",
         data: aAccessible.value,
         options: {enqueue: aIsPolite}
       }
     };
   };
 
 B2GPresenter.prototype.textChanged = function B2GPresenter_textChanged(
   aAccessible, aIsInserted, aStart, aLength, aText, aModifiedText) {
     let echoSetting = this.keyboardEchoSetting.value;
-    let text = '';
+    let text = "";
 
     if (echoSetting == this.CHARACTER_ECHO ||
         echoSetting == this.CHARACTER_AND_WORD_ECHO) {
       text = aModifiedText;
     }
 
     // add word if word boundary is added
     if ((echoSetting == this.WORD_ECHO ||
@@ -579,89 +579,89 @@ B2GPresenter.prototype.textChanged = fun
       if (endBefore.value !== endAfter.value) {
         text += maybeWord;
       }
     }
 
     return {
       type: this.type,
       details: {
-        eventType: 'text-change',
+        eventType: "text-change",
         data: text
       }
     };
 
   };
 
 B2GPresenter.prototype.actionInvoked =
   function B2GPresenter_actionInvoked(aObject, aActionName) {
     return {
       type: this.type,
       details: {
-        eventType: 'action',
+        eventType: "action",
         data: UtteranceGenerator.genForAction(aObject, aActionName)
       }
     };
   };
 
 B2GPresenter.prototype.liveRegion = function B2GPresenter_liveRegion(aContext,
   aIsPolite, aIsHide, aModifiedText) {
     return {
       type: this.type,
       details: {
-        eventType: 'liveregion-change',
+        eventType: "liveregion-change",
         data: UtteranceGenerator.genForLiveRegion(aContext, aIsHide,
           aModifiedText),
         options: {enqueue: aIsPolite}
       }
     };
   };
 
 B2GPresenter.prototype.announce =
   function B2GPresenter_announce(aAnnouncement) {
     return {
       type: this.type,
       details: {
-        eventType: 'announcement',
+        eventType: "announcement",
         data: aAnnouncement
       }
     };
   };
 
 B2GPresenter.prototype.noMove =
   function B2GPresenter_noMove(aMoveMethod) {
     return {
       type: this.type,
       details: {
-        eventType: 'no-move',
+        eventType: "no-move",
         data: aMoveMethod
       }
     };
   };
 
 /**
  * A braille presenter
  */
 function BraillePresenter() {}
 
 BraillePresenter.prototype = Object.create(Presenter.prototype);
 
-BraillePresenter.prototype.type = 'Braille';
+BraillePresenter.prototype.type = "Braille";
 
 BraillePresenter.prototype.pivotChanged =
   function BraillePresenter_pivotChanged(aContext) {
     if (!aContext.accessible) {
       return null;
     }
 
     return {
       type: this.type,
       details: {
         output: Utils.localize(BrailleGenerator.genForContext(aContext)).join(
-          ' '),
+          " "),
         selectionStart: 0,
         selectionEnd: 0
       }
     };
   };
 
 BraillePresenter.prototype.textSelectionChanged =
   function BraillePresenter_textSelectionChanged(aText, aStart, aEnd) {
@@ -673,19 +673,19 @@ BraillePresenter.prototype.textSelection
       }
     };
   };
 
 this.Presentation = { // jshint ignore:line
   get presenters() {
     delete this.presenters;
     let presenterMap = {
-      'mobile/android': [VisualPresenter, AndroidPresenter],
-      'b2g': [VisualPresenter, B2GPresenter],
-      'browser': [VisualPresenter, B2GPresenter, AndroidPresenter]
+      "mobile/android": [VisualPresenter, AndroidPresenter],
+      "b2g": [VisualPresenter, B2GPresenter],
+      "browser": [VisualPresenter, B2GPresenter, AndroidPresenter]
     };
     this.presenters = presenterMap[Utils.MozBuildApp].map(P => new P());
     return this.presenters;
   },
 
   get displayedAccessibles() {
     delete this.displayedAccessibles;
     this.displayedAccessibles = new WeakMap();
--- a/accessible/jsat/Traversal.jsm
+++ b/accessible/jsat/Traversal.jsm
@@ -1,33 +1,33 @@
 /* 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/. */
 
 /* exported TraversalRules, TraversalHelper */
 
-'use strict';
+"use strict";
 
 const Ci = Components.interfaces;
 const Cu = Components.utils;
 
-this.EXPORTED_SYMBOLS = ['TraversalRules', 'TraversalHelper']; // jshint ignore:line
+this.EXPORTED_SYMBOLS = ["TraversalRules", "TraversalHelper"]; // jshint ignore:line
 
-Cu.import('resource://gre/modules/accessibility/Utils.jsm');
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Roles',  // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Filters',  // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'States',  // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Prefilters',  // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
+Cu.import("resource://gre/modules/accessibility/Utils.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Roles",  // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Filters",  // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "States",  // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Prefilters",  // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
 
-var gSkipEmptyImages = new PrefCache('accessibility.accessfu.skip_empty_images');
+var gSkipEmptyImages = new PrefCache("accessibility.accessfu.skip_empty_images");
 
 function BaseTraversalRule(aRoles, aMatchFunc, aPreFilter, aContainerRule) {
   this._explicitMatchRoles = new Set(aRoles);
   this._matchRoles = aRoles;
   if (aRoles.length) {
     if (aRoles.indexOf(Roles.LABEL) < 0) {
       this._matchRoles.push(Roles.LABEL);
     }
@@ -227,23 +227,23 @@ this.TraversalRules = { // jshint ignore
   Section: new BaseTraversalRule(
     [],
     function Section_match(aAccessible) {
       if (aAccessible.role === Roles.HEADING) {
         return Filters.MATCH;
       }
 
       let matchedRole = Utils.matchRoles(aAccessible, [
-        'banner',
-        'complementary',
-        'contentinfo',
-        'main',
-        'navigation',
-        'search',
-        'region'
+        "banner",
+        "complementary",
+        "contentinfo",
+        "main",
+        "navigation",
+        "search",
+        "region"
         ]);
 
       return matchedRole ? Filters.MATCH : Filters.IGNORE;
     }, null, true),
 
   Entry: new BaseTraversalRule(
     [Roles.ENTRY,
      Roles.PASSWORD_TEXT]),
@@ -356,17 +356,17 @@ this.TraversalRules = { // jshint ignore
     [Roles.TABLE]),
 
   Checkbox: new BaseTraversalRule(
     [Roles.CHECKBUTTON,
      Roles.CHECK_MENU_ITEM,
      Roles.SWITCH /* A type of checkbox that represents on/off values */]),
 
   _shouldSkipImage: function _shouldSkipImage(aAccessible) {
-    if (gSkipEmptyImages.value && aAccessible.name === '') {
+    if (gSkipEmptyImages.value && aAccessible.name === "") {
       return Filters.IGNORE;
     }
     return Filters.MATCH;
   }
 };
 
 this.TraversalHelper = {
   _helperPivotCache: null,
--- a/accessible/jsat/Utils.jsm
+++ b/accessible/jsat/Utils.jsm
@@ -1,49 +1,49 @@
 /* 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/. */
 
 /* exported Utils, Logger, PivotContext, PrefCache */
 
-'use strict';
+"use strict";
 
 const {classes: Cc, utils: Cu, interfaces: Ci} = Components;
 
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Services', // jshint ignore:line
-  'resource://gre/modules/Services.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Rect', // jshint ignore:line
-  'resource://gre/modules/Geometry.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Roles', // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Events', // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Relations', // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'States', // jshint ignore:line
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'PluralForm', // jshint ignore:line
-  'resource://gre/modules/PluralForm.jsm');
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Services", // jshint ignore:line
+  "resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Rect", // jshint ignore:line
+  "resource://gre/modules/Geometry.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Roles", // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Events", // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Relations", // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "States", // jshint ignore:line
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PluralForm", // jshint ignore:line
+  "resource://gre/modules/PluralForm.jsm");
 
-this.EXPORTED_SYMBOLS = ['Utils', 'Logger', 'PivotContext', 'PrefCache']; // jshint ignore:line
+this.EXPORTED_SYMBOLS = ["Utils", "Logger", "PivotContext", "PrefCache"]; // jshint ignore:line
 
 this.Utils = { // jshint ignore:line
   _buildAppMap: {
-    '{3c2e2abc-06d4-11e1-ac3b-374f68613e61}': 'b2g',
-    '{d1bfe7d9-c01e-4237-998b-7b5f960a4314}': 'graphene',
-    '{ec8030f7-c20a-464f-9b0e-13a3a9e97384}': 'browser',
-    '{aa3c5121-dab2-40e2-81ca-7ea25febc110}': 'mobile/android',
-    '{a23983c0-fd0e-11dc-95ff-0800200c9a66}': 'mobile/xul'
+    "{3c2e2abc-06d4-11e1-ac3b-374f68613e61}": "b2g",
+    "{d1bfe7d9-c01e-4237-998b-7b5f960a4314}": "graphene",
+    "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": "browser",
+    "{aa3c5121-dab2-40e2-81ca-7ea25febc110}": "mobile/android",
+    "{a23983c0-fd0e-11dc-95ff-0800200c9a66}": "mobile/xul"
   },
 
   init: function Utils_init(aWindow) {
     if (this._win) {
       // XXX: only supports attaching to one window now.
-      throw new Error('Only one top-level window could used with AccessFu');
+      throw new Error("Only one top-level window could used with AccessFu");
     }
     this._win = Cu.getWeakReference(aWindow);
   },
 
   uninit: function Utils_uninit() {
     if (!this._win) {
       return;
     }
@@ -63,17 +63,17 @@ this.Utils = { // jshint ignore:line
       return null;
     }
     return win.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(
       Ci.nsIDOMWindowUtils);
   },
 
   get AccService() {
     if (!this._AccService) {
-      this._AccService = Cc['@mozilla.org/accessibilityService;1'].
+      this._AccService = Cc["@mozilla.org/accessibilityService;1"].
         getService(Ci.nsIAccessibilityService);
     }
 
     return this._AccService;
   },
 
   set MozBuildApp(value) {
     this._buildApp = value;
@@ -98,26 +98,26 @@ this.Utils = { // jshint ignore:line
       this._widgetToolkit = Services.appinfo.widgetToolkit;
     }
     return this._widgetToolkit;
   },
 
   get ScriptName() {
     if (!this._ScriptName) {
       this._ScriptName =
-        (Services.appinfo.processType == 2) ? 'AccessFuContent' : 'AccessFu';
+        (Services.appinfo.processType == 2) ? "AccessFuContent" : "AccessFu";
     }
     return this._ScriptName;
   },
 
   get AndroidSdkVersion() {
     if (!this._AndroidSdkVersion) {
-      if (Services.appinfo.OS == 'Android') {
+      if (Services.appinfo.OS == "Android") {
         this._AndroidSdkVersion = Services.sysinfo.getPropertyAsInt32(
-          'version');
+          "version");
       } else {
         // Most useful in desktop debugging.
         this._AndroidSdkVersion = 16;
       }
     }
     return this._AndroidSdkVersion;
   },
 
@@ -126,32 +126,32 @@ this.Utils = { // jshint ignore:line
     this._AndroidSdkVersion = value;
   },
 
   get BrowserApp() {
     if (!this.win) {
       return null;
     }
     switch (this.MozBuildApp) {
-      case 'mobile/android':
+      case "mobile/android":
         return this.win.BrowserApp;
-      case 'browser':
+      case "browser":
         return this.win.gBrowser;
-      case 'b2g':
+      case "b2g":
         return this.win.shell;
       default:
         return null;
     }
   },
 
   get CurrentBrowser() {
     if (!this.BrowserApp) {
       return null;
     }
-    if (this.MozBuildApp == 'b2g') {
+    if (this.MozBuildApp == "b2g") {
       return this.BrowserApp.contentBrowser;
     }
     return this.BrowserApp.selectedBrowser;
   },
 
   get CurrentContentDoc() {
     let browser = this.CurrentBrowser;
     return browser ? browser.contentDocument : null;
@@ -159,37 +159,37 @@ this.Utils = { // jshint ignore:line
 
   get AllMessageManagers() {
     let messageManagers = new Set();
 
     function collectLeafMessageManagers(mm) {
       for (let i = 0; i < mm.childCount; i++) {
         let childMM = mm.getChildAt(i);
 
-        if ('sendAsyncMessage' in childMM) {
+        if ("sendAsyncMessage" in childMM) {
           messageManagers.add(childMM);
         } else {
           collectLeafMessageManagers(childMM);
         }
       }
     }
 
     collectLeafMessageManagers(this.win.messageManager);
 
     let document = this.CurrentContentDoc;
 
     if (document) {
-      if (document.location.host === 'b2g') {
+      if (document.location.host === "b2g") {
         // The document is a b2g app chrome (ie. Mulet).
         let contentBrowser = this.win.content.shell.contentBrowser;
         messageManagers.add(this.getMessageManager(contentBrowser));
         document = contentBrowser.contentDocument;
       }
 
-      let remoteframes = document.querySelectorAll('iframe');
+      let remoteframes = document.querySelectorAll("iframe");
 
       for (let i = 0; i < remoteframes.length; ++i) {
         let mm = this.getMessageManager(remoteframes[i]);
         if (mm) {
           messageManagers.add(mm);
         }
       }
 
@@ -212,41 +212,41 @@ this.Utils = { // jshint ignore:line
     // Clean up the white space.
     return localized.filter(word => word).map(word => word.trim()).
       filter(trimmed => trimmed);
   },
 
   get stringBundle() {
     delete this.stringBundle;
     let bundle = Services.strings.createBundle(
-      'chrome://global/locale/AccessFu.properties');
+      "chrome://global/locale/AccessFu.properties");
     this.stringBundle = {
       get: function stringBundle_get(aDetails = {}) {
-        if (!aDetails || typeof aDetails === 'string') {
+        if (!aDetails || typeof aDetails === "string") {
           return aDetails;
         }
-        let str = '';
+        let str = "";
         let string = aDetails.string;
         if (!string) {
           return str;
         }
         try {
           let args = aDetails.args;
           let count = aDetails.count;
           if (args) {
             str = bundle.formatStringFromName(string, args, args.length);
           } else {
             str = bundle.GetStringFromName(string);
           }
           if (count) {
             str = PluralForm.get(count, str);
-            str = str.replace('#1', count);
+            str = str.replace("#1", count);
           }
         } catch (e) {
-          Logger.debug('Failed to get a string from a bundle for', string);
+          Logger.debug("Failed to get a string from a bundle for", string);
         } finally {
           return str;
         }
       }
     };
     return this.stringBundle;
   },
 
@@ -359,29 +359,29 @@ this.Utils = { // jshint ignore:line
     while (acc) {
       if (acc == aSubTreeRoot) {
         return true;
       }
 
       try {
         acc = acc.parent;
       } catch (x) {
-        Logger.debug('Failed to get parent:', x);
+        Logger.debug("Failed to get parent:", x);
         acc = null;
       }
     }
 
     return false;
   },
 
   isHidden: function isHidden(aAccessible) {
     // Need to account for aria-hidden, so can't just check for INVISIBLE
     // state.
     let hidden = Utils.getAttributes(aAccessible).hidden;
-    return hidden && hidden === 'true';
+    return hidden && hidden === "true";
   },
 
   visibleChildCount: function visibleChildCount(aAccessible) {
     let count = 0;
     for (let child = aAccessible.firstChild; child; child = child.nextSibling) {
       if (!this.isHidden(child)) {
         ++count;
       }
@@ -413,54 +413,54 @@ this.Utils = { // jshint ignore:line
     } catch (x) {
       return false;
     }
 
     return true;
   },
 
   matchAttributeValue: function matchAttributeValue(aAttributeValue, values) {
-    let attrSet = new Set(aAttributeValue.split(' '));
+    let attrSet = new Set(aAttributeValue.split(" "));
     for (let value of values) {
       if (attrSet.has(value)) {
         return value;
       }
     }
   },
 
   getLandmarkName: function getLandmarkName(aAccessible) {
     return this.matchRoles(aAccessible, [
-      'banner',
-      'complementary',
-      'contentinfo',
-      'main',
-      'navigation',
-      'search'
+      "banner",
+      "complementary",
+      "contentinfo",
+      "main",
+      "navigation",
+      "search"
     ]);
   },
 
   getMathRole: function getMathRole(aAccessible) {
     return this.matchRoles(aAccessible, [
-      'base',
-      'close-fence',
-      'denominator',
-      'numerator',
-      'open-fence',
-      'overscript',
-      'presubscript',
-      'presuperscript',
-      'root-index',
-      'subscript',
-      'superscript',
-      'underscript'
+      "base",
+      "close-fence",
+      "denominator",
+      "numerator",
+      "open-fence",
+      "overscript",
+      "presubscript",
+      "presuperscript",
+      "root-index",
+      "subscript",
+      "superscript",
+      "underscript"
     ]);
   },
 
   matchRoles: function matchRoles(aAccessible, aRoles) {
-    let roles = this.getAttributes(aAccessible)['xml-roles'];
+    let roles = this.getAttributes(aAccessible)["xml-roles"];
     if (!roles) {
       return;
     }
 
     // Looking up a role that would match any in the provided roles.
     return this.matchAttributeValue(roles, aRoles);
   },
 
@@ -476,29 +476,29 @@ this.Utils = { // jshint ignore:line
     }
 
     return null;
   },
 
   isListItemDecorator: function isListItemDecorator(aStaticText,
                                                     aExcludeOrdered) {
     let parent = aStaticText.parent;
-    if (aExcludeOrdered && parent.parent.DOMNode.nodeName === 'OL') {
+    if (aExcludeOrdered && parent.parent.DOMNode.nodeName === "OL") {
       return false;
     }
 
     return parent.role === Roles.LISTITEM && parent.childCount > 1 &&
       aStaticText.indexInParent === 0;
   },
 
   dispatchChromeEvent: function dispatchChromeEvent(aType, aDetails) {
     let details = {
       type: aType,
       details: JSON.stringify(
-        typeof aDetails === 'string' ? { eventType: aDetails } : aDetails)
+        typeof aDetails === "string" ? { eventType: aDetails } : aDetails)
     };
     let window = this.win;
     let shell = window.shell || window.content.shell;
     if (shell) {
       // On B2G device.
       shell.sendChromeEvent(details);
     } else {
       // Dispatch custom event to have support for desktop and screen reader
@@ -511,17 +511,17 @@ this.Utils = { // jshint ignore:line
     }
 
   },
 
   isActivatableOnFingerUp: function isActivatableOnFingerUp(aAccessible) {
     if (aAccessible.role === Roles.KEY) {
       return true;
     }
-    let quick_activate = this.getAttributes(aAccessible)['moz-quick-activate'];
+    let quick_activate = this.getAttributes(aAccessible)["moz-quick-activate"];
     return quick_activate && JSON.parse(quick_activate);
   }
 };
 
 /**
  * State object used internally to process accessible's states.
  * @param {Number} aBase     Base state.
  * @param {Number} aExtended Extended state.
@@ -537,41 +537,41 @@ State.prototype = {
   },
   toString: function State_toString() {
     let stateStrings = Utils.AccService.
       getStringStates(this.base, this.extended);
     let statesArray = new Array(stateStrings.length);
     for (let i = 0; i < statesArray.length; i++) {
       statesArray[i] = stateStrings.item(i);
     }
-    return '[' + statesArray.join(', ') + ']';
+    return "[" + statesArray.join(", ") + "]";
   }
 };
 
 this.Logger = { // jshint ignore:line
   GESTURE: -1,
   DEBUG: 0,
   INFO: 1,
   WARNING: 2,
   ERROR: 3,
-  _LEVEL_NAMES: ['GESTURE', 'DEBUG', 'INFO', 'WARNING', 'ERROR'],
+  _LEVEL_NAMES: ["GESTURE", "DEBUG", "INFO", "WARNING", "ERROR"],
 
   logLevel: 1, // INFO;
 
   test: false,
 
   log: function log(aLogLevel) {
     if (aLogLevel < this.logLevel) {
       return;
     }
 
     let args = Array.prototype.slice.call(arguments, 1);
-    let message = (typeof(args[0]) === 'function' ? args[0]() : args).join(' ');
-    message = '[' + Utils.ScriptName + '] ' + this._LEVEL_NAMES[aLogLevel + 1] +
-      ' ' + message + '\n';
+    let message = (typeof(args[0]) === "function" ? args[0]() : args).join(" ");
+    message = "[" + Utils.ScriptName + "] " + this._LEVEL_NAMES[aLogLevel + 1] +
+      " " + message + "\n";
     dump(message);
     // Note: used for testing purposes. If |this.test| is true, also log to
     // the console service.
     if (this.test) {
       try {
         Services.console.logStringMessage(message);
       } catch (ex) {
         // There was an exception logging to the console service.
@@ -600,72 +600,72 @@ this.Logger = { // jshint ignore:line
   },
 
   error: function error() {
     this.log.apply(
       this, [this.ERROR].concat(Array.prototype.slice.call(arguments)));
   },
 
   logException: function logException(
-    aException, aErrorMessage = 'An exception has occured') {
+    aException, aErrorMessage = "An exception has occured") {
     try {
-      let stackMessage = '';
+      let stackMessage = "";
       if (aException.stack) {
-        stackMessage = '  ' + aException.stack.replace(/\n/g, '\n  ');
+        stackMessage = "  " + aException.stack.replace(/\n/g, "\n  ");
       } else if (aException.location) {
         let frame = aException.location;
         let stackLines = [];
         while (frame && frame.lineNumber) {
           stackLines.push(
-            '  ' + frame.name + '@' + frame.filename + ':' + frame.lineNumber);
+            "  " + frame.name + "@" + frame.filename + ":" + frame.lineNumber);
           frame = frame.caller;
         }
-        stackMessage = stackLines.join('\n');
+        stackMessage = stackLines.join("\n");
       } else {
         stackMessage =
-          '(' + aException.fileName + ':' + aException.lineNumber + ')';
+          "(" + aException.fileName + ":" + aException.lineNumber + ")";
       }
-      this.error(aErrorMessage + ':\n ' +
-                 aException.message + '\n' +
+      this.error(aErrorMessage + ":\n " +
+                 aException.message + "\n" +
                  stackMessage);
     } catch (x) {
       this.error(x);
     }
   },
 
   accessibleToString: function accessibleToString(aAccessible) {
     if (!aAccessible) {
-      return '[ null ]';
+      return "[ null ]";
     }
 
     try {
-      return '[ ' + Utils.AccService.getStringRole(aAccessible.role) +
-        ' | ' + aAccessible.name + ' ]';
+      return "[ " + Utils.AccService.getStringRole(aAccessible.role) +
+        " | " + aAccessible.name + " ]";
     } catch (x) {
-      return '[ defunct ]';
+      return "[ defunct ]";
     }
   },
 
   eventToString: function eventToString(aEvent) {
     let str = Utils.AccService.getStringEventType(aEvent.eventType);
     if (aEvent.eventType == Events.STATE_CHANGE) {
       let event = aEvent.QueryInterface(Ci.nsIAccessibleStateChangeEvent);
       let stateStrings = event.isExtraState ?
         Utils.AccService.getStringStates(0, event.state) :
         Utils.AccService.getStringStates(event.state, 0);
-      str += ' (' + stateStrings.item(0) + ')';
+      str += " (" + stateStrings.item(0) + ")";
     }
 
     if (aEvent.eventType == Events.VIRTUALCURSOR_CHANGED) {
       let event = aEvent.QueryInterface(
         Ci.nsIAccessibleVirtualCursorChangeEvent);
       let pivot = aEvent.accessible.QueryInterface(
         Ci.nsIAccessibleDocument).virtualCursor;
-      str += ' (' + this.accessibleToString(event.oldAccessible) + ' -> ' +
-        this.accessibleToString(pivot.position) + ')';
+      str += " (" + this.accessibleToString(event.oldAccessible) + " -> " +
+        this.accessibleToString(pivot.position) + ")";
     }
 
     return str;
   },
 
   statesToString: function statesToString(aAccessible) {
     return Utils.getState(aAccessible).toString();
   },
@@ -675,23 +675,23 @@ this.Logger = { // jshint ignore:line
       return;
     }
 
     this._dumpTreeInternal(aLogLevel, aRootAccessible, 0);
   },
 
   _dumpTreeInternal:
     function _dumpTreeInternal(aLogLevel, aAccessible, aIndent) {
-      let indentStr = '';
+      let indentStr = "";
       for (let i = 0; i < aIndent; i++) {
-        indentStr += ' ';
+        indentStr += " ";
       }
       this.log(aLogLevel, indentStr,
                this.accessibleToString(aAccessible),
-               '(' + this.statesToString(aAccessible) + ')');
+               "(" + this.statesToString(aAccessible) + ")");
       for (let i = 0; i < aAccessible.childCount; i++) {
         this._dumpTreeInternal(aLogLevel, aAccessible.getChildAt(i),
           aIndent + 1);
       }
     }
 };
 
 /**
@@ -749,26 +749,26 @@ PivotContext.prototype = {
                             Ci.nsIAccessibleText.TEXT_OFFSET_END_OF_TEXT)};
       let hypertextAcc = this._accessible.QueryInterface(
         Ci.nsIAccessibleHyperText);
 
       // Iterate through the links in backwards order so text replacements don't
       // affect the offsets of links yet to be processed.
       for (let i = hypertextAcc.linkCount - 1; i >= 0; i--) {
         let link = hypertextAcc.getLinkAt(i);
-        let linkText = '';
+        let linkText = "";
         if (link instanceof Ci.nsIAccessibleText) {
           linkText = link.QueryInterface(Ci.nsIAccessibleText).
                           getText(0,
                             Ci.nsIAccessibleText.TEXT_OFFSET_END_OF_TEXT);
         }
 
         let start = link.startIndex;
         let end = link.endIndex;
-        for (let offset of ['startOffset', 'endOffset']) {
+        for (let offset of ["startOffset", "endOffset"]) {
           if (this[offset] >= end) {
             result[offset] += linkText.length - (end - start);
           }
         }
         result.text = result.text.substring(0, start) + linkText +
                       result.text.substring(end);
       }
 
@@ -787,17 +787,17 @@ PivotContext.prototype = {
     let ancestry = [];
     let parent = aAccessible;
     try {
       while (parent && (parent = parent.parent)) {
        ancestry.push(parent);
       }
     } catch (x) {
       // A defunct accessible will raise an exception geting parent.
-      Logger.debug('Failed to get parent:', x);
+      Logger.debug("Failed to get parent:", x);
     }
     return ancestry.reverse();
   },
 
   /**
    * A list of the old accessible's ancestry.
    */
   get oldAncestry() {
@@ -874,23 +874,23 @@ PivotContext.prototype = {
 
   /**
    * Get interaction hints for the context ancestry.
    * @return {Array} Array of interaction hints.
    */
   get interactionHints() {
     let hints = [];
     this.newAncestry.concat(this.accessible).reverse().forEach(aAccessible => {
-      let hint = Utils.getAttributes(aAccessible)['moz-hint'];
+      let hint = Utils.getAttributes(aAccessible)["moz-hint"];
       if (hint) {
         hints.push(hint);
       } else if (aAccessible.actionCount > 0) {
         hints.push({
           string: Utils.AccService.getStringRole(
-            aAccessible.role).replace(/\s/g, '') + '-hint'
+            aAccessible.role).replace(/\s/g, "") + "-hint"
         });
       }
     });
     return hints;
   },
 
   /*
    * A subtree generator function, used to generate a flattened
@@ -941,17 +941,17 @@ PivotContext.prototype = {
         yield enumerator.getNext().QueryInterface(Ci.nsIAccessible).name;
       }
     };
 
     cellInfo.current = getAccessibleCell(aAccessible);
 
     if (!cellInfo.current) {
       Logger.warning(aAccessible,
-        'does not support nsIAccessibleTableCell interface.');
+        "does not support nsIAccessibleTableCell interface.");
       this._cells.set(domNode, null);
       return null;
     }
 
     let table = cellInfo.current.table;
     if (table.isProbablyForLayout()) {
       this._cells.set(domNode, null);
       return null;
@@ -1053,17 +1053,17 @@ PrefCache.prototype = {
     } catch (x) {
       // Pref does not exist.
       return null;
     }
   },
 
   observe: function observe(aSubject) {
     this.value = this._getValue(aSubject.QueryInterface(Ci.nsIPrefBranch));
-    Logger.info('pref changed', this.name, this.value);
+    Logger.info("pref changed", this.name, this.value);
     if (this.callback) {
       try {
         this.callback(this.name, this.value, false);
       } catch (x) {
         Logger.logException(x);
       }
     }
   },
--- a/accessible/jsat/content-script.js
+++ b/accessible/jsat/content-script.js
@@ -2,152 +2,152 @@
  * 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/. */
 
 /* eslint-env mozilla/frame-script */
 
 var Ci = Components.interfaces;
 var Cu = Components.utils;
 
-Cu.import('resource://gre/modules/XPCOMUtils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Logger',
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Presentation',
-  'resource://gre/modules/accessibility/Presentation.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Utils',
-  'resource://gre/modules/accessibility/Utils.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'EventManager',
-  'resource://gre/modules/accessibility/EventManager.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'ContentControl',
-  'resource://gre/modules/accessibility/ContentControl.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'Roles',
-  'resource://gre/modules/accessibility/Constants.jsm');
-XPCOMUtils.defineLazyModuleGetter(this, 'States',
-  'resource://gre/modules/accessibility/Constants.jsm');
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Logger",
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Presentation",
+  "resource://gre/modules/accessibility/Presentation.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Utils",
+  "resource://gre/modules/accessibility/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "EventManager",
+  "resource://gre/modules/accessibility/EventManager.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ContentControl",
+  "resource://gre/modules/accessibility/ContentControl.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Roles",
+  "resource://gre/modules/accessibility/Constants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "States",
+  "resource://gre/modules/accessibility/Constants.jsm");
 
-Logger.info('content-script.js', content.document.location);
+Logger.info("content-script.js", content.document.location);
 
 var eventManager = null;
 var contentControl = null;
 
 function forwardToParent(aMessage) {
   // XXX: This is a silly way to make a deep copy
   let newJSON = JSON.parse(JSON.stringify(aMessage.json));
-  newJSON.origin = 'child';
+  newJSON.origin = "child";
   sendAsyncMessage(aMessage.name, newJSON);
 }
 
 function forwardToChild(aMessage, aListener, aVCPosition) {
   let acc = aVCPosition || Utils.getVirtualCursor(content.document).position;
 
   if (!Utils.isAliveAndVisible(acc) || acc.role != Roles.INTERNAL_FRAME) {
     return false;
   }
 
   Logger.debug(() => {
-    return ['forwardToChild', Logger.accessibleToString(acc),
-            aMessage.name, JSON.stringify(aMessage.json, null, '  ')];
+    return ["forwardToChild", Logger.accessibleToString(acc),
+            aMessage.name, JSON.stringify(aMessage.json, null, "  ")];
   });
 
   let mm = Utils.getMessageManager(acc.DOMNode);
 
   if (aListener) {
     mm.addMessageListener(aMessage.name, aListener);
   }
 
   // XXX: This is a silly way to make a deep copy
   let newJSON = JSON.parse(JSON.stringify(aMessage.json));
-  newJSON.origin = 'parent';
+  newJSON.origin = "parent";
   if (Utils.isContentProcess) {
     // XXX: OOP content's screen offset is 0,
     // so we remove the real screen offset here.
     newJSON.x -= content.mozInnerScreenX;
     newJSON.y -= content.mozInnerScreenY;
   }
   mm.sendAsyncMessage(aMessage.name, newJSON);
   return true;
 }
 
 function activateContextMenu(aMessage) {
   let position = Utils.getVirtualCursor(content.document).position;
   if (!forwardToChild(aMessage, activateContextMenu, position)) {
     let center = Utils.getBounds(position, true).center();
 
-    let evt = content.document.createEvent('HTMLEvents');
-    evt.initEvent('contextmenu', true, true);
+    let evt = content.document.createEvent("HTMLEvents");
+    evt.initEvent("contextmenu", true, true);
     evt.clientX = center.x;
     evt.clientY = center.y;
     position.DOMNode.dispatchEvent(evt);
   }
 }
 
 function presentCaretChange(aText, aOldOffset, aNewOffset) {
   if (aOldOffset !== aNewOffset) {
     let msg = Presentation.textSelectionChanged(aText, aNewOffset, aNewOffset,
                                                 aOldOffset, aOldOffset, true);
-    sendAsyncMessage('AccessFu:Present', msg);
+    sendAsyncMessage("AccessFu:Present", msg);
   }
 }
 
 function scroll(aMessage) {
   let position = Utils.getVirtualCursor(content.document).position;
   if (!forwardToChild(aMessage, scroll, position)) {
-    sendAsyncMessage('AccessFu:DoScroll',
+    sendAsyncMessage("AccessFu:DoScroll",
                      { bounds: Utils.getBounds(position, true),
                        page: aMessage.json.page,
                        horizontal: aMessage.json.horizontal });
   }
 }
 
 addMessageListener(
-  'AccessFu:Start',
+  "AccessFu:Start",
   function(m) {
     if (m.json.logLevel) {
       Logger.logLevel = Logger[m.json.logLevel];
     }
 
-    Logger.debug('AccessFu:Start');
+    Logger.debug("AccessFu:Start");
     if (m.json.buildApp)
       Utils.MozBuildApp = m.json.buildApp;
 
-    addMessageListener('AccessFu:ContextMenu', activateContextMenu);
-    addMessageListener('AccessFu:Scroll', scroll);
+    addMessageListener("AccessFu:ContextMenu", activateContextMenu);
+    addMessageListener("AccessFu:Scroll", scroll);
 
     if (!contentControl) {
       contentControl = new ContentControl(this);
     }
     contentControl.start();
 
     if (!eventManager) {
       eventManager = new EventManager(this, contentControl);
     }
     eventManager.inTest = m.json.inTest;
     eventManager.start();
 
     function contentStarted() {
       let accDoc = Utils.AccService.getAccessibleFor(content.document);
       if (accDoc && !Utils.getState(accDoc).contains(States.BUSY)) {
-        sendAsyncMessage('AccessFu:ContentStarted');
+        sendAsyncMessage("AccessFu:ContentStarted");
       } else {
         content.setTimeout(contentStarted, 0);
       }
     }
 
     if (m.json.inTest) {
       // During a test we want to wait for the document to finish loading for
       // consistency.
       contentStarted();
     }
   });
 
 addMessageListener(
-  'AccessFu:Stop',
+  "AccessFu:Stop",
   function(m) {
-    Logger.debug('AccessFu:Stop');
+    Logger.debug("AccessFu:Stop");
 
-    removeMessageListener('AccessFu:ContextMenu', activateContextMenu);
-    removeMessageListener('AccessFu:Scroll', scroll);
+    removeMessageListener("AccessFu:ContextMenu", activateContextMenu);
+    removeMessageListener("AccessFu:Scroll", scroll);
 
     eventManager.stop();
     contentControl.stop();
   });
 
-sendAsyncMessage('AccessFu:Ready');
+sendAsyncMessage("AccessFu:Ready");
--- a/accessible/tests/browser/bounds/browser_test_zoom.js
+++ b/accessible/tests/browser/bounds/browser_test_zoom.js
@@ -21,17 +21,17 @@ async function testContentBounds(browser
   let prettyAccName = prettyName(acc);
   is(x, expectedX, "Wrong x coordinate of " + prettyAccName);
   is(y, expectedY, "Wrong y coordinate of " + prettyAccName);
   is(width, expectedWidth, "Wrong width of " + prettyAccName);
   is(height, expectedHeight, "Wrong height of " + prettyAccName);
 }
 
 async function runTests(browser, accDoc) {
-  loadFrameScripts(browser, { name: 'layout.js', dir: MOCHITESTS_DIR });
+  loadFrameScripts(browser, { name: "layout.js", dir: MOCHITESTS_DIR });
 
   let p1 = findAccessibleChildByID(accDoc, "p1");
   let p2 = findAccessibleChildByID(accDoc, "p2");
   let imgmap = findAccessibleChildByID(accDoc, "imgmap");
   if (!imgmap.childCount) {
     // An image map may not be available even after the doc and image load
     // is complete. We don't recieve any DOM events for this change either,
     // so we need to wait for a REORDER.
--- a/accessible/tests/browser/bounds/browser_test_zoom_text.js
+++ b/accessible/tests/browser/bounds/browser_test_zoom_text.js
@@ -11,17 +11,17 @@ async function runTests(browser, accDoc)
     let hyperTextNode = findAccessibleChildByID(accDoc, id);
     let textNode = hyperTextNode.firstChild;
 
     let [x, y, width, height] = getBounds(textNode);
     testTextBounds(hyperTextNode, 0, -1, [x, y, width, height],
                    COORDTYPE_SCREEN_RELATIVE);
   }
 
-  loadFrameScripts(browser, { name: 'layout.js', dir: MOCHITESTS_DIR });
+  loadFrameScripts(browser, { name: "layout.js", dir: MOCHITESTS_DIR });
 
   testTextNode("p1");
   testTextNode("p2");
 
   await ContentTask.spawn(browser, {}, () => {
     zoomDocument(document, 2.0);
   });
 
--- a/accessible/tests/browser/bounds/head.js
+++ b/accessible/tests/browser/bounds/head.js
@@ -1,16 +1,16 @@
 /* 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';
+"use strict";
 
 // Load the shared-head file first.
 /* import-globals-from ../shared-head.js */
 Services.scriptloader.loadSubScript(
-  'chrome://mochitests/content/browser/accessible/tests/browser/shared-head.js',
+  "chrome://mochitests/content/browser/accessible/tests/browser/shared-head.js",
   this);
 
 // Loading and common.js from accessible/tests/mochitest/ for all tests, as
 // well as events.js.
-loadScripts({ name: 'common.js', dir: MOCHITESTS_DIR },
-            { name: 'layout.js', dir: MOCHITESTS_DIR }, 'events.js');
+loadScripts({ name: "common.js", dir: MOCHITESTS_DIR },
+            { name: "layout.js", dir: MOCHITESTS_DIR }, "events.js");
--- a/accessible/tests/browser/browser_shutdown_acc_reference.js
+++ b/accessible/tests/browser/browser_shutdown_acc_reference.js
@@ -1,55 +1,55 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Create a11y service.
   let a11yInit = initPromise();
-  let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
 
   await a11yInit;
-  ok(accService, 'Service initialized');
+  ok(accService, "Service initialized");
 
   // Accessible object reference will live longer than the scope of this
   // function.
   let acc = await new Promise(resolve => {
     let intervalId = setInterval(() => {
       let tabAcc = accService.getAccessibleFor(gBrowser.mCurrentTab);
       if (tabAcc) {
         clearInterval(intervalId);
         resolve(tabAcc);
       }
     }, 10);
   });
-  ok(acc, 'Accessible object is created');
+  ok(acc, "Accessible object is created");
 
   let canShutdown = false;
   // This promise will resolve only if canShutdown flag is set to true. If
   // 'a11y-init-or-shutdown' event with '0' flag comes before it can be shut
   // down, the promise will reject.
   let a11yShutdown = new Promise((resolve, reject) =>
     shutdownPromise().then(flag => canShutdown ? resolve() :
-      reject('Accessible service was shut down incorrectly')));
+      reject("Accessible service was shut down incorrectly")));
 
   accService = null;
-  ok(!accService, 'Service is removed');
+  ok(!accService, "Service is removed");
 
   // Force garbage collection that should not trigger shutdown because there is
   // a reference to an accessible object.
   forceGC();
   // Have some breathing room when removing a11y service references.
   await new Promise(resolve => executeSoon(resolve));
 
   // Now allow a11y service to shutdown.
   canShutdown = true;
   // Remove a reference to an accessible object.
   acc = null;
-  ok(!acc, 'Accessible object is removed');
+  ok(!acc, "Accessible object is removed");
 
   // Force garbage collection that should now trigger shutdown.
   forceGC();
   await a11yShutdown;
 });
--- a/accessible/tests/browser/browser_shutdown_doc_acc_reference.js
+++ b/accessible/tests/browser/browser_shutdown_doc_acc_reference.js
@@ -1,47 +1,47 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Create a11y service.
   let a11yInit = initPromise();
-  let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
 
   await a11yInit;
-  ok(accService, 'Service initialized');
+  ok(accService, "Service initialized");
 
   // Accessible document reference will live longer than the scope of this
   // function.
   let docAcc = accService.getAccessibleFor(document);
-  ok(docAcc, 'Accessible document is created');
+  ok(docAcc, "Accessible document is created");
 
   let canShutdown = false;
   // This promise will resolve only if canShutdown flag is set to true. If
   // 'a11y-init-or-shutdown' event with '0' flag comes before it can be shut
   // down, the promise will reject.
   let a11yShutdown = new Promise((resolve, reject) =>
     shutdownPromise().then(flag => canShutdown ? resolve() :
-      reject('Accessible service was shut down incorrectly')));
+      reject("Accessible service was shut down incorrectly")));
 
   accService = null;
-  ok(!accService, 'Service is removed');
+  ok(!accService, "Service is removed");
 
   // Force garbage collection that should not trigger shutdown because there is
   // a reference to an accessible document.
   forceGC();
   // Have some breathing room when removing a11y service references.
   await new Promise(resolve => executeSoon(resolve));
 
   // Now allow a11y service to shutdown.
   canShutdown = true;
   // Remove a reference to an accessible document.
   docAcc = null;
-  ok(!docAcc, 'Accessible document is removed');
+  ok(!docAcc, "Accessible document is removed");
 
   // Force garbage collection that should now trigger shutdown.
   forceGC();
   await a11yShutdown;
 });
--- a/accessible/tests/browser/browser_shutdown_multi_acc_reference_doc.js
+++ b/accessible/tests/browser/browser_shutdown_multi_acc_reference_doc.js
@@ -1,67 +1,67 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Create a11y service.
   let a11yInit = initPromise();
-  let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
 
   await a11yInit;
-  ok(accService, 'Service initialized');
+  ok(accService, "Service initialized");
 
   let docAcc = accService.getAccessibleFor(document);
-  ok(docAcc, 'Accessible document is created');
+  ok(docAcc, "Accessible document is created");
 
   // Accessible object reference will live longer than the scope of this
   // function.
   let acc = await new Promise(resolve => {
     let intervalId = setInterval(() => {
       let tabAcc = accService.getAccessibleFor(gBrowser.mCurrentTab);
       if (tabAcc) {
         clearInterval(intervalId);
         resolve(tabAcc);
       }
     }, 10);
   });
-  ok(acc, 'Accessible object is created');
+  ok(acc, "Accessible object is created");
 
   let canShutdown = false;
   // This promise will resolve only if canShutdown flag is set to true. If
   // 'a11y-init-or-shutdown' event with '0' flag comes before it can be shut
   // down, the promise will reject.
   let a11yShutdown = new Promise((resolve, reject) =>
     shutdownPromise().then(flag => canShutdown ? resolve() :
-      reject('Accessible service was shut down incorrectly')));
+      reject("Accessible service was shut down incorrectly")));
 
   accService = null;
-  ok(!accService, 'Service is removed');
+  ok(!accService, "Service is removed");
 
   // Force garbage collection that should not trigger shutdown because there are
   // references to accessible objects.
   forceGC();
   // Have some breathing room when removing a11y service references.
   await new Promise(resolve => executeSoon(resolve));
 
   // Remove a reference to an accessible object.
   acc = null;
-  ok(!acc, 'Accessible object is removed');
+  ok(!acc, "Accessible object is removed");
   // Force garbage collection that should not trigger shutdown because there is
   // a reference to an accessible document.
   forceGC();
   // Have some breathing room when removing a11y service references.
   await new Promise(resolve => executeSoon(resolve));
 
   // Now allow a11y service to shutdown.
   canShutdown = true;
   // Remove a reference to an accessible document.
   docAcc = null;
-  ok(!docAcc, 'Accessible document is removed');
+  ok(!docAcc, "Accessible document is removed");
 
   // Force garbage collection that should now trigger shutdown.
   forceGC();
   await a11yShutdown;
 });
--- a/accessible/tests/browser/browser_shutdown_multi_acc_reference_obj.js
+++ b/accessible/tests/browser/browser_shutdown_multi_acc_reference_obj.js
@@ -1,67 +1,67 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Create a11y service.
   let a11yInit = initPromise();
-  let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
 
   await a11yInit;
-  ok(accService, 'Service initialized');
+  ok(accService, "Service initialized");
 
   let docAcc = accService.getAccessibleFor(document);
-  ok(docAcc, 'Accessible document is created');
+  ok(docAcc, "Accessible document is created");
 
   // Accessible object reference will live longer than the scope of this
   // function.
   let acc = await new Promise(resolve => {
     let intervalId = setInterval(() => {
       let tabAcc = accService.getAccessibleFor(gBrowser.mCurrentTab);
       if (tabAcc) {
         clearInterval(intervalId);
         resolve(tabAcc);
       }
     }, 10);
   });
-  ok(acc, 'Accessible object is created');
+  ok(acc, "Accessible object is created");
 
   let canShutdown = false;
   // This promise will resolve only if canShutdown flag is set to true. If
   // 'a11y-init-or-shutdown' event with '0' flag comes before it can be shut
   // down, the promise will reject.
   let a11yShutdown = new Promise((resolve, reject) =>
     shutdownPromise().then(flag => canShutdown ? resolve() :
-      reject('Accessible service was shut down incorrectly')));
+      reject("Accessible service was shut down incorrectly")));
 
   accService = null;
-  ok(!accService, 'Service is removed');
+  ok(!accService, "Service is removed");
 
   // Force garbage collection that should not trigger shutdown because there are
   // references to accessible objects.
   forceGC();
   // Have some breathing room when removing a11y service references.
   await new Promise(resolve => executeSoon(resolve));
 
   // Remove a reference to an accessible document.
   docAcc = null;
-  ok(!docAcc, 'Accessible document is removed');
+  ok(!docAcc, "Accessible document is removed");
   // Force garbage collection that should not trigger shutdown because there is
   // a reference to an accessible object.
   forceGC();
   // Have some breathing room when removing a11y service references.
   await new Promise(resolve => executeSoon(resolve));
 
   // Now allow a11y service to shutdown.
   canShutdown = true;
   // Remove a reference to an accessible object.
   acc = null;
-  ok(!acc, 'Accessible object is removed');
+  ok(!acc, "Accessible object is removed");
 
   // Force garbage collection that should now trigger shutdown.
   forceGC();
   await a11yShutdown;
 });
--- a/accessible/tests/browser/browser_shutdown_multi_proxy_acc_reference_doc.js
+++ b/accessible/tests/browser/browser_shutdown_multi_proxy_acc_reference_doc.js
@@ -1,75 +1,75 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Making sure that the e10s is enabled on Windows for testing.
   await setE10sPrefs();
 
   let docLoaded = waitForEvent(
-    Ci.nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_COMPLETE, 'body');
+    Ci.nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_COMPLETE, "body");
   let a11yInit = initPromise();
-  let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
-  ok(accService, 'Service initialized');
+  ok(accService, "Service initialized");
   await a11yInit;
 
   await BrowserTestUtils.withNewTab({
     gBrowser,
     url: `data:text/html,
       <html>
         <head>
           <meta charset="utf-8"/>
           <title>Accessibility Test</title>
         </head>
         <body id="body"><div id="div"></div></body>
       </html>`
   }, async function(browser) {
     let docLoadedEvent = await docLoaded;
     let docAcc = docLoadedEvent.accessibleDocument;
-    ok(docAcc, 'Accessible document proxy is created');
+    ok(docAcc, "Accessible document proxy is created");
     // Remove unnecessary dangling references
     docLoaded = null;
     docLoadedEvent = null;
     forceGC();
 
     let acc = docAcc.getChildAt(0);
-    ok(acc, 'Accessible proxy is created');
+    ok(acc, "Accessible proxy is created");
 
     let canShutdown = false;
     let a11yShutdown = new Promise((resolve, reject) =>
     shutdownPromise().then(flag => canShutdown ? resolve() :
-      reject('Accessible service was shut down incorrectly')));
+      reject("Accessible service was shut down incorrectly")));
 
     accService = null;
-    ok(!accService, 'Service is removed');
+    ok(!accService, "Service is removed");
     // Force garbage collection that should not trigger shutdown because there
     // is a reference to an accessible proxy.
     forceGC();
     // Have some breathing room when removing a11y service references.
     await new Promise(resolve => executeSoon(resolve));
 
     // Remove a reference to an accessible proxy.
     acc = null;
-    ok(!acc, 'Accessible proxy is removed');
+    ok(!acc, "Accessible proxy is removed");
     // Force garbage collection that should not trigger shutdown because there is
     // a reference to an accessible document proxy.
     forceGC();
     // Have some breathing room when removing a11y service references.
     await new Promise(resolve => executeSoon(resolve));
 
     // Now allow a11y service to shutdown.
     canShutdown = true;
     // Remove a last reference to an accessible document proxy.
     docAcc = null;
-    ok(!docAcc, 'Accessible document proxy is removed');
+    ok(!docAcc, "Accessible document proxy is removed");
 
     // Force garbage collection that should now trigger shutdown.
     forceGC();
     await a11yShutdown;
   });
 
   // Unsetting e10s related preferences.
   await unsetE10sPrefs();
--- a/accessible/tests/browser/browser_shutdown_multi_proxy_acc_reference_obj.js
+++ b/accessible/tests/browser/browser_shutdown_multi_proxy_acc_reference_obj.js
@@ -1,75 +1,75 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Making sure that the e10s is enabled on Windows for testing.
   await setE10sPrefs();
 
   let docLoaded = waitForEvent(
-    Ci.nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_COMPLETE, 'body');
+    Ci.nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_COMPLETE, "body");
   let a11yInit = initPromise();
-  let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
-  ok(accService, 'Service initialized');
+  ok(accService, "Service initialized");
   await a11yInit;
 
   await BrowserTestUtils.withNewTab({
     gBrowser,
     url: `data:text/html,
       <html>
         <head>
           <meta charset="utf-8"/>
           <title>Accessibility Test</title>
         </head>
         <body id="body"><div id="div"></div></body>
       </html>`
   }, async function(browser) {
     let docLoadedEvent = await docLoaded;
     let docAcc = docLoadedEvent.accessibleDocument;
-    ok(docAcc, 'Accessible document proxy is created');
+    ok(docAcc, "Accessible document proxy is created");
     // Remove unnecessary dangling references
     docLoaded = null;
     docLoadedEvent = null;
     forceGC();
 
     let acc = docAcc.getChildAt(0);
-    ok(acc, 'Accessible proxy is created');
+    ok(acc, "Accessible proxy is created");
 
     let canShutdown = false;
     let a11yShutdown = new Promise((resolve, reject) =>
     shutdownPromise().then(flag => canShutdown ? resolve() :
-      reject('Accessible service was shut down incorrectly')));
+      reject("Accessible service was shut down incorrectly")));
 
     accService = null;
-    ok(!accService, 'Service is removed');
+    ok(!accService, "Service is removed");
     // Force garbage collection that should not trigger shutdown because there
     // is a reference to an accessible proxy.
     forceGC();
     // Have some breathing room when removing a11y service references.
     await new Promise(resolve => executeSoon(resolve));
 
     // Remove a reference to an accessible document proxy.
     docAcc = null;
-    ok(!docAcc, 'Accessible document proxy is removed');
+    ok(!docAcc, "Accessible document proxy is removed");
     // Force garbage collection that should not trigger shutdown because there is
     // a reference to an accessible proxy.
     forceGC();
     // Have some breathing room when removing a11y service references.
     await new Promise(resolve => executeSoon(resolve));
 
     // Now allow a11y service to shutdown.
     canShutdown = true;
     // Remove a last reference to an accessible proxy.
     acc = null;
-    ok(!acc, 'Accessible proxy is removed');
+    ok(!acc, "Accessible proxy is removed");
 
     // Force garbage collection that should now trigger shutdown.
     forceGC();
     await a11yShutdown;
   });
 
   // Unsetting e10s related preferences.
   await unsetE10sPrefs();
--- a/accessible/tests/browser/browser_shutdown_multi_reference.js
+++ b/accessible/tests/browser/browser_shutdown_multi_reference.js
@@ -1,48 +1,48 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
-  info('Creating a service');
+  info("Creating a service");
   // Create a11y service.
   let a11yInit = initPromise();
-  let accService1 = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService1 = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
   await a11yInit;
-  ok(accService1, 'Service initialized');
+  ok(accService1, "Service initialized");
 
   // Add another reference to a11y service. This will not trigger
   // 'a11y-init-or-shutdown' event
-  let accService2 = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService2 = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
-  ok(accService2, 'Service initialized');
+  ok(accService2, "Service initialized");
 
-  info('Removing all service references');
+  info("Removing all service references");
   let canShutdown = false;
   // This promise will resolve only if canShutdown flag is set to true. If
   // 'a11y-init-or-shutdown' event with '0' flag comes before it can be shut
   // down, the promise will reject.
   let a11yShutdown = new Promise((resolve, reject) =>
     shutdownPromise().then(flag => canShutdown ?
-      resolve() : reject('Accessible service was shut down incorrectly')));
+      resolve() : reject("Accessible service was shut down incorrectly")));
   // Remove first a11y service reference.
   accService1 = null;
-  ok(!accService1, 'Service is removed');
+  ok(!accService1, "Service is removed");
   // Force garbage collection that should not trigger shutdown because there is
   // another reference.
   forceGC();
 
   // Have some breathing room when removing a11y service references.
   await new Promise(resolve => executeSoon(resolve));
 
   // Now allow a11y service to shutdown.
   canShutdown = true;
   // Remove last a11y service reference.
   accService2 = null;
-  ok(!accService2, 'Service is removed');
+  ok(!accService2, "Service is removed");
   // Force garbage collection that should trigger shutdown.
   forceGC();
   await a11yShutdown;
 });
--- a/accessible/tests/browser/browser_shutdown_parent_own_reference.js
+++ b/accessible/tests/browser/browser_shutdown_parent_own_reference.js
@@ -1,71 +1,71 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Making sure that the e10s is enabled on Windows for testing.
   await setE10sPrefs();
 
   await BrowserTestUtils.withNewTab({
     gBrowser,
     url: `data:text/html,
       <html>
         <head>
           <meta charset="utf-8"/>
           <title>Accessibility Test</title>
         </head>
         <body></body>
       </html>`
   }, async function(browser) {
-    info('Creating a service in parent and waiting for service to be created ' +
-      'in content');
+    info("Creating a service in parent and waiting for service to be created " +
+      "in content");
     // Create a11y service in the main process. This will trigger creating of
     // the a11y service in parent as well.
     let parentA11yInit = initPromise();
     let contentA11yInit = initPromise(browser);
-    let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+    let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
       Ci.nsIAccessibilityService);
-    ok(accService, 'Service initialized in parent');
+    ok(accService, "Service initialized in parent");
     await Promise.all([parentA11yInit, contentA11yInit]);
 
-    info('Adding additional reference to accessibility service in content ' +
-      'process');
+    info("Adding additional reference to accessibility service in content " +
+      "process");
     // Add a new reference to the a11y service inside the content process.
     loadFrameScripts(browser, `let accService = Components.classes[
       '@mozilla.org/accessibilityService;1'].getService(
         Components.interfaces.nsIAccessibilityService);`);
 
-    info('Trying to shut down a service in content and making sure it stays ' +
-      'alive as it was started by parent');
+    info("Trying to shut down a service in content and making sure it stays " +
+      "alive as it was started by parent");
     let contentCanShutdown = false;
     // This promise will resolve only if contentCanShutdown flag is set to true.
     // If 'a11y-init-or-shutdown' event with '0' flag (in content) comes before
     // it can be shut down, the promise will reject.
     let contentA11yShutdown = new Promise((resolve, reject) =>
       shutdownPromise(browser).then(flag => contentCanShutdown ?
-        resolve() : reject('Accessible service was shut down incorrectly')));
+        resolve() : reject("Accessible service was shut down incorrectly")));
     // Remove a11y service reference in content and force garbage collection.
     // This should not trigger shutdown since a11y was originally initialized by
     // the main process.
     loadFrameScripts(browser, `accService = null; Components.utils.forceGC();`);
 
     // Have some breathing room between a11y service shutdowns.
     await new Promise(resolve => executeSoon(resolve));
 
-    info('Removing a service in parent');
+    info("Removing a service in parent");
     // Now allow a11y service to shutdown in content.
     contentCanShutdown = true;
     // Remove the a11y service reference in the main process.
     let parentA11yShutdown = shutdownPromise();
     accService = null;
-    ok(!accService, 'Service is removed in parent');
+    ok(!accService, "Service is removed in parent");
     // Force garbage collection that should trigger shutdown in both parent and
     // content.
     forceGC();
     await Promise.all([parentA11yShutdown, contentA11yShutdown]);
 
     // Unsetting e10s related preferences.
     await unsetE10sPrefs();
   });
--- a/accessible/tests/browser/browser_shutdown_proxy_acc_reference.js
+++ b/accessible/tests/browser/browser_shutdown_proxy_acc_reference.js
@@ -1,63 +1,63 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Making sure that the e10s is enabled on Windows for testing.
   await setE10sPrefs();
 
   let a11yInit = initPromise();
-  let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
-  ok(accService, 'Service initialized');
+  ok(accService, "Service initialized");
   await a11yInit;
 
   await BrowserTestUtils.withNewTab({
     gBrowser,
     url: `data:text/html,
       <html>
         <head>
           <meta charset="utf-8"/>
           <title>Accessibility Test</title>
         </head>
         <body><div id="div" style="visibility: hidden;"></div></body>
       </html>`
   }, async function(browser) {
-    let onShow = waitForEvent(Ci.nsIAccessibleEvent.EVENT_SHOW, 'div');
-    await invokeSetStyle(browser, 'div', 'visibility', 'visible');
+    let onShow = waitForEvent(Ci.nsIAccessibleEvent.EVENT_SHOW, "div");
+    await invokeSetStyle(browser, "div", "visibility", "visible");
     let showEvent = await onShow;
     let divAcc = showEvent.accessible;
-    ok(divAcc, 'Accessible proxy is created');
+    ok(divAcc, "Accessible proxy is created");
     // Remove unnecessary dangling references
     onShow = null;
     showEvent = null;
     forceGC();
 
     let canShutdown = false;
     let a11yShutdown = new Promise((resolve, reject) =>
     shutdownPromise().then(flag => canShutdown ? resolve() :
-      reject('Accessible service was shut down incorrectly')));
+      reject("Accessible service was shut down incorrectly")));
 
     accService = null;
-    ok(!accService, 'Service is removed');
+    ok(!accService, "Service is removed");
     // Force garbage collection that should not trigger shutdown because there
     // is a reference to an accessible proxy.
     forceGC();
     // Have some breathing room when removing a11y service references.
     await new Promise(resolve => executeSoon(resolve));
 
     // Now allow a11y service to shutdown.
     canShutdown = true;
     // Remove a last reference to an accessible proxy.
     divAcc = null;
-    ok(!divAcc, 'Accessible proxy is removed');
+    ok(!divAcc, "Accessible proxy is removed");
 
     // Force garbage collection that should now trigger shutdown.
     forceGC();
     await a11yShutdown;
   });
 
   // Unsetting e10s related preferences.
   await unsetE10sPrefs();
--- a/accessible/tests/browser/browser_shutdown_proxy_doc_acc_reference.js
+++ b/accessible/tests/browser/browser_shutdown_proxy_doc_acc_reference.js
@@ -1,63 +1,63 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Making sure that the e10s is enabled on Windows for testing.
   await setE10sPrefs();
 
   let docLoaded = waitForEvent(
-    Ci.nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_COMPLETE, 'body');
+    Ci.nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_COMPLETE, "body");
   let a11yInit = initPromise();
-  let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
-  ok(accService, 'Service initialized');
+  ok(accService, "Service initialized");
   await a11yInit;
 
   await BrowserTestUtils.withNewTab({
     gBrowser,
     url: `data:text/html,
       <html>
         <head>
           <meta charset="utf-8"/>
           <title>Accessibility Test</title>
         </head>
         <body id="body"></body>
       </html>`
   }, async function(browser) {
     let docLoadedEvent = await docLoaded;
     let docAcc = docLoadedEvent.accessibleDocument;
-    ok(docAcc, 'Accessible document proxy is created');
+    ok(docAcc, "Accessible document proxy is created");
     // Remove unnecessary dangling references
     docLoaded = null;
     docLoadedEvent = null;
     forceGC();
 
     let canShutdown = false;
     let a11yShutdown = new Promise((resolve, reject) =>
     shutdownPromise().then(flag => canShutdown ? resolve() :
-      reject('Accessible service was shut down incorrectly')));
+      reject("Accessible service was shut down incorrectly")));
 
     accService = null;
-    ok(!accService, 'Service is removed');
+    ok(!accService, "Service is removed");
     // Force garbage collection that should not trigger shutdown because there
     // is a reference to an accessible proxy.
     forceGC();
     // Have some breathing room when removing a11y service references.
     await new Promise(resolve => executeSoon(resolve));
 
     // Now allow a11y service to shutdown.
     canShutdown = true;
     // Remove a last reference to an accessible document proxy.
     docAcc = null;
-    ok(!docAcc, 'Accessible document proxy is removed');
+    ok(!docAcc, "Accessible document proxy is removed");
 
     // Force garbage collection that should now trigger shutdown.
     forceGC();
     await a11yShutdown;
   });
 
   // Unsetting e10s related preferences.
   await unsetE10sPrefs();
--- a/accessible/tests/browser/browser_shutdown_remote_no_reference.js
+++ b/accessible/tests/browser/browser_shutdown_remote_no_reference.js
@@ -1,47 +1,47 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Making sure that the e10s is enabled on Windows for testing.
   await setE10sPrefs();
 
   await BrowserTestUtils.withNewTab({
     gBrowser,
     url: `data:text/html,
       <html>
         <head>
           <meta charset="utf-8"/>
           <title>Accessibility Test</title>
         </head>
         <body></body>
       </html>`
   }, async function(browser) {
-    info('Creating a service in parent and waiting for service to be created ' +
-      'in content');
+    info("Creating a service in parent and waiting for service to be created " +
+      "in content");
     // Create a11y service in the main process. This will trigger creating of
     // the a11y service in parent as well.
     let parentA11yInit = initPromise();
     let contentA11yInit = initPromise(browser);
-    let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+    let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
       Ci.nsIAccessibilityService);
-    ok(accService, 'Service initialized in parent');
+    ok(accService, "Service initialized in parent");
     await Promise.all([parentA11yInit, contentA11yInit]);
 
-    info('Removing a service in parent and waiting for service to be shut ' +
-      'down in content');
+    info("Removing a service in parent and waiting for service to be shut " +
+      "down in content");
     // Remove a11y service reference in the main process.
     let parentA11yShutdown = shutdownPromise();
     let contentA11yShutdown = shutdownPromise(browser);
     accService = null;
-    ok(!accService, 'Service is removed in parent');
+    ok(!accService, "Service is removed in parent");
     // Force garbage collection that should trigger shutdown in both main and
     // content process.
     forceGC();
     await Promise.all([parentA11yShutdown, contentA11yShutdown]);
   });
 
   // Unsetting e10s related preferences.
   await unsetE10sPrefs();
--- a/accessible/tests/browser/browser_shutdown_remote_only.js
+++ b/accessible/tests/browser/browser_shutdown_remote_only.js
@@ -1,38 +1,38 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Making sure that the e10s is enabled on Windows for testing.
   await setE10sPrefs();
 
   await BrowserTestUtils.withNewTab({
     gBrowser,
     url: `data:text/html,
       <html>
         <head>
           <meta charset="utf-8"/>
           <title>Accessibility Test</title>
         </head>
         <body></body>
       </html>`
   }, async function(browser) {
-    info('Creating a service in content');
+    info("Creating a service in content");
     // Create a11y service in the content process.
     let a11yInit = initPromise(browser);
     loadFrameScripts(browser, `let accService = Components.classes[
       '@mozilla.org/accessibilityService;1'].getService(
         Components.interfaces.nsIAccessibilityService);`);
     await a11yInit;
 
-    info('Removing a service in content');
+    info("Removing a service in content");
     // Remove a11y service reference from the content process.
     let a11yShutdown = shutdownPromise(browser);
     // Force garbage collection that should trigger shutdown.
     loadFrameScripts(browser, `accService = null; Components.utils.forceGC();`);
     await a11yShutdown;
 
     // Unsetting e10s related preferences.
     await unsetE10sPrefs();
--- a/accessible/tests/browser/browser_shutdown_remote_own_reference.js
+++ b/accessible/tests/browser/browser_shutdown_remote_own_reference.js
@@ -1,72 +1,72 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Making sure that the e10s is enabled on Windows for testing.
   await setE10sPrefs();
 
   await BrowserTestUtils.withNewTab({
     gBrowser,
     url: `data:text/html,
       <html>
         <head>
           <meta charset="utf-8"/>
           <title>Accessibility Test</title>
         </head>
         <body></body>
       </html>`
   }, async function(browser) {
-    info('Creating a service in parent and waiting for service to be created ' +
-      'in content');
+    info("Creating a service in parent and waiting for service to be created " +
+      "in content");
     // Create a11y service in the main process. This will trigger creating of
     // the a11y service in parent as well.
     let parentA11yInit = initPromise();
     let contentA11yInit = initPromise(browser);
-    let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+    let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
       Ci.nsIAccessibilityService);
-    ok(accService, 'Service initialized in parent');
+    ok(accService, "Service initialized in parent");
     await Promise.all([parentA11yInit, contentA11yInit]);
 
-    info('Adding additional reference to accessibility service in content ' +
-      'process');
+    info("Adding additional reference to accessibility service in content " +
+      "process");
     // Add a new reference to the a11y service inside the content process.
     loadFrameScripts(browser, `let accService = Components.classes[
       '@mozilla.org/accessibilityService;1'].getService(
         Components.interfaces.nsIAccessibilityService);`);
 
-    info('Shutting down a service in parent and making sure the one in ' +
-      'content stays alive');
+    info("Shutting down a service in parent and making sure the one in " +
+      "content stays alive");
     let contentCanShutdown = false;
     let parentA11yShutdown = shutdownPromise();
     // This promise will resolve only if contentCanShutdown flag is set to true.
     // If 'a11y-init-or-shutdown' event with '0' flag (in content) comes before
     // it can be shut down, the promise will reject.
     let contentA11yShutdown = new Promise((resolve, reject) =>
       shutdownPromise(browser).then(flag => contentCanShutdown ?
-        resolve() : reject('Accessible service was shut down incorrectly')));
+        resolve() : reject("Accessible service was shut down incorrectly")));
     // Remove a11y service reference in the main process and force garbage
     // collection. This should not trigger shutdown in content since a11y
     // service is used by XPCOM.
     accService = null;
-    ok(!accService, 'Service is removed in parent');
+    ok(!accService, "Service is removed in parent");
     // Force garbage collection that should not trigger shutdown because there
     // is a reference in a content process.
     forceGC();
     loadFrameScripts(browser, `Components.utils.forceGC();`);
     await parentA11yShutdown;
 
     // Have some breathing room between a11y service shutdowns.
     await new Promise(resolve => executeSoon(resolve));
 
-    info('Removing a service in content');
+    info("Removing a service in content");
     // Now allow a11y service to shutdown in content.
     contentCanShutdown = true;
     // Remove last reference to a11y service in content and force garbage
     // collection that should trigger shutdown.
     loadFrameScripts(browser, `accService = null; Components.utils.forceGC();`);
     await contentA11yShutdown;
 
     // Unsetting e10s related preferences.
--- a/accessible/tests/browser/browser_shutdown_scope_lifecycle.js
+++ b/accessible/tests/browser/browser_shutdown_scope_lifecycle.js
@@ -1,21 +1,21 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
   // Create a11y service inside of the function scope. Its reference should be
   // released once the anonimous function is called.
   let a11yInitThenShutdown = initPromise().then(shutdownPromise);
 
   (function() {
-    let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+    let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
       Ci.nsIAccessibilityService);
-    ok(accService, 'Service initialized');
+    ok(accService, "Service initialized");
   })();
 
   // Force garbage collection that should trigger shutdown.
   forceGC();
   await a11yInitThenShutdown;
 });
--- a/accessible/tests/browser/browser_shutdown_start_restart.js
+++ b/accessible/tests/browser/browser_shutdown_start_restart.js
@@ -1,41 +1,41 @@
 /* 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';
+"use strict";
 
 add_task(async function () {
-  info('Creating a service');
+  info("Creating a service");
   // Create a11y service.
   let a11yInit = initPromise();
-  let accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  let accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
   await a11yInit;
-  ok(accService, 'Service initialized');
+  ok(accService, "Service initialized");
 
-  info('Removing a service');
+  info("Removing a service");
   // Remove the only reference to an a11y service.
   let a11yShutdown = shutdownPromise();
   accService = null;
-  ok(!accService, 'Service is removed');
+  ok(!accService, "Service is removed");
   // Force garbage collection that should trigger shutdown.
   forceGC();
   await a11yShutdown;
 
-  info('Recreating a service');
+  info("Recreating a service");
   // Re-create a11y service.
   a11yInit = initPromise();
-  accService = Cc['@mozilla.org/accessibilityService;1'].getService(
+  accService = Cc["@mozilla.org/accessibilityService;1"].getService(
     Ci.nsIAccessibilityService);
   await a11yInit;
-  ok(accService, 'Service initialized again');
+  ok(accService, "Service initialized again");
 
-  info('Removing a service again');
+  info("Removing a service again");
   // Remove the only reference to an a11y service again.
   a11yShutdown = shutdownPromise();
   accService = null;
-  ok(!accService, 'Service is removed again');
+  ok(!accService, "Service is removed again");
   // Force garbage collection that should trigger shutdown.
   forceGC();
   await a11yShutdown;
 });
--- a/accessible/tests/browser/e10s/browser_caching_attributes.js
+++ b/accessible/tests/browser/e10s/browser_caching_attributes.js
@@ -1,115 +1,115 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/attributes.js */
-loadScripts({ name: 'attributes.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "attributes.js", dir: MOCHITESTS_DIR });
 
 /**
  * Default textbox accessible attributes.
  */
 const defaultAttributes = {
-  'margin-top': '0px',
-  'margin-right': '0px',
-  'margin-bottom': '0px',
-  'margin-left': '0px',
-  'text-align': 'start',
-  'text-indent': '0px',
-  'id': 'textbox',
-  'tag': 'input',
-  'display': 'inline'
+  "margin-top": "0px",
+  "margin-right": "0px",
+  "margin-bottom": "0px",
+  "margin-left": "0px",
+  "text-align": "start",
+  "text-indent": "0px",
+  "id": "textbox",
+  "tag": "input",
+  "display": "inline"
 };
 
 /**
  * Test data has the format of:
  * {
  *   desc        {String}         description for better logging
  *   expected    {Object}         expected attributes for given accessibles
  *   unexpected  {Object}         unexpected attributes for given accessibles
  *
  *   action      {?AsyncFunction} an optional action that awaits a change in
  *                                attributes
  *   attrs       {?Array}         an optional list of attributes to update
  *   waitFor     {?Number}        an optional event to wait for
  * }
  */
 const attributesTests = [{
-  desc: 'Initiall accessible attributes',
+  desc: "Initiall accessible attributes",
   expected: defaultAttributes,
   unexpected: {
-    'line-number': '1',
-    'explicit-name': 'true',
-    'container-live': 'polite',
-    'live': 'polite'
+    "line-number": "1",
+    "explicit-name": "true",
+    "container-live": "polite",
+    "live": "polite"
   }
 }, {
-  desc: '@line-number attribute is present when textbox is focused',
+  desc: "@line-number attribute is present when textbox is focused",
   action: async function(browser) {
-    await invokeFocus(browser, 'textbox');
+    await invokeFocus(browser, "textbox");
   },
   waitFor: EVENT_FOCUS,
-  expected: Object.assign({}, defaultAttributes, { 'line-number': '1' }),
+  expected: Object.assign({}, defaultAttributes, { "line-number": "1" }),
   unexpected: {
-    'explicit-name': 'true',
-    'container-live': 'polite',
-    'live': 'polite'
+    "explicit-name": "true",
+    "container-live": "polite",
+    "live": "polite"
   }
 }, {
-  desc: '@aria-live sets container-live and live attributes',
+  desc: "@aria-live sets container-live and live attributes",
   attrs: [{
-    attr: 'aria-live',
-    value: 'polite'
+    attr: "aria-live",
+    value: "polite"
   }],
   expected: Object.assign({}, defaultAttributes, {
-    'line-number': '1',
-    'container-live': 'polite',
-    'live': 'polite'
+    "line-number": "1",
+    "container-live": "polite",
+    "live": "polite"
   }),
   unexpected: {
-    'explicit-name': 'true'
+    "explicit-name": "true"
   }
 }, {
-  desc: '@title attribute sets explicit-name attribute to true',
+  desc: "@title attribute sets explicit-name attribute to true",
   attrs: [{
-    attr: 'title',
-    value: 'textbox'
+    attr: "title",
+    value: "textbox"
   }],
   expected: Object.assign({}, defaultAttributes, {
-    'line-number': '1',
-    'explicit-name': 'true',
-    'container-live': 'polite',
-    'live': 'polite'
+    "line-number": "1",
+    "explicit-name": "true",
+    "container-live": "polite",
+    "live": "polite"
   }),
   unexpected: {}
 }];
 
 /**
  * Test caching of accessible object attributes
  */
 addAccessibleTask(`
   <input id="textbox" value="hello">`,
   async function (browser, accDoc) {
-    let textbox = findAccessibleChildByID(accDoc, 'textbox');
+    let textbox = findAccessibleChildByID(accDoc, "textbox");
     for (let { desc, action, attrs, expected, waitFor, unexpected } of attributesTests) {
       info(desc);
       let onUpdate;
 
       if (waitFor) {
-        onUpdate = waitForEvent(waitFor, 'textbox');
+        onUpdate = waitForEvent(waitFor, "textbox");
       }
 
       if (action) {
         await action(browser);
       } else if (attrs) {
         for (let { attr, value } of attrs) {
-          await invokeSetAttribute(browser, 'textbox', attr, value);
+          await invokeSetAttribute(browser, "textbox", attr, value);
         }
       }
 
       await onUpdate;
       testAttrs(textbox, expected);
       testAbsentAttrs(textbox, unexpected);
     }
   }
--- a/accessible/tests/browser/e10s/browser_caching_description.js
+++ b/accessible/tests/browser/e10s/browser_caching_description.js
@@ -1,163 +1,163 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/name.js */
-loadScripts({ name: 'name.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "name.js", dir: MOCHITESTS_DIR });
 
 /**
  * Test data has the format of:
  * {
  *   desc      {String}   description for better logging
  *   expected  {String}   expected description value for a given accessible
  *   attrs     {?Array}   an optional list of attributes to update
  *   waitFor   {?Array}   an optional list of accessible events to wait for when
  *                        attributes are updated
  * }
  */
 const tests = [{
-  desc: 'No description when there are no @alt, @title and @aria-describedby',
-  expected: ''
+  desc: "No description when there are no @alt, @title and @aria-describedby",
+  expected: ""
 }, {
-  desc: 'Description from @aria-describedby attribute',
+  desc: "Description from @aria-describedby attribute",
   attrs: [{
-    attr: 'aria-describedby',
-    value: 'description'
+    attr: "aria-describedby",
+    value: "description"
   }],
-  waitFor: [[EVENT_DESCRIPTION_CHANGE, 'image']],
-  expected: 'aria description'
+  waitFor: [[EVENT_DESCRIPTION_CHANGE, "image"]],
+  expected: "aria description"
 }, {
-  desc: 'No description from @aria-describedby since it is the same as the ' +
-        '@alt attribute which is used as the name',
+  desc: "No description from @aria-describedby since it is the same as the " +
+        "@alt attribute which is used as the name",
   attrs: [{
-    attr: 'alt',
-    value: 'aria description'
+    attr: "alt",
+    value: "aria description"
   }],
-  waitFor: [[EVENT_REORDER, 'body']],
-  expected: ''
+  waitFor: [[EVENT_REORDER, "body"]],
+  expected: ""
 }, {
-  desc: 'Description from @aria-describedby attribute when @alt and ' +
-        '@aria-describedby are not the same',
+  desc: "Description from @aria-describedby attribute when @alt and " +
+        "@aria-describedby are not the same",
   attrs: [{
-    attr: 'aria-describedby',
-    value: 'description2'
+    attr: "aria-describedby",
+    value: "description2"
   }],
-  waitFor: [[EVENT_DESCRIPTION_CHANGE, 'image']],
-  expected: 'another description'
+  waitFor: [[EVENT_DESCRIPTION_CHANGE, "image"]],
+  expected: "another description"
 }, {
-  desc: 'Description from @aria-describedby attribute when @title (used for ' +
-        'name) and @aria-describedby are not the same',
+  desc: "Description from @aria-describedby attribute when @title (used for " +
+        "name) and @aria-describedby are not the same",
   attrs: [{
-    attr: 'alt'
+    attr: "alt"
   }, {
-    attr: 'title',
-    value: 'title'
+    attr: "title",
+    value: "title"
   }],
-  waitFor: [[EVENT_REORDER, 'body']],
-  expected: 'another description'
+  waitFor: [[EVENT_REORDER, "body"]],
+  expected: "another description"
 }, {
-  desc: 'No description from @aria-describedby since it is the same as the ' +
-        '@title attribute which is used as the name',
+  desc: "No description from @aria-describedby since it is the same as the " +
+        "@title attribute which is used as the name",
   attrs: [{
-    attr: 'title',
-    value: 'another description'
+    attr: "title",
+    value: "another description"
   }],
-  waitFor: [[EVENT_NAME_CHANGE, 'image']],
-  expected: ''
+  waitFor: [[EVENT_NAME_CHANGE, "image"]],
+  expected: ""
 }, {
-  desc: 'No description with only @title attribute which is used as the name',
+  desc: "No description with only @title attribute which is used as the name",
   attrs: [{
-    attr: 'aria-describedby'
+    attr: "aria-describedby"
   }],
-  waitFor: [[EVENT_DESCRIPTION_CHANGE, 'image']],
-  expected: ''
+  waitFor: [[EVENT_DESCRIPTION_CHANGE, "image"]],
+  expected: ""
 }, {
-  desc: 'Description from @title attribute when @alt and @atitle are not the ' +
-        'same',
+  desc: "Description from @title attribute when @alt and @atitle are not the " +
+        "same",
   attrs: [{
-    attr: 'alt',
-    value: 'aria description'
+    attr: "alt",
+    value: "aria description"
   }],
-  waitFor: [[EVENT_REORDER, 'body']],
-  expected: 'another description'
+  waitFor: [[EVENT_REORDER, "body"]],
+  expected: "another description"
 }, {
-  desc: 'No description from @title since it is the same as the @alt ' +
-        'attribute which is used as the name',
+  desc: "No description from @title since it is the same as the @alt " +
+        "attribute which is used as the name",
   attrs: [{
-    attr: 'alt',
-    value: 'another description'
+    attr: "alt",
+    value: "another description"
   }],
-  waitFor: [[EVENT_NAME_CHANGE, 'image']],
-  expected: ''
+  waitFor: [[EVENT_NAME_CHANGE, "image"]],
+  expected: ""
 }, {
-  desc: 'No description from @aria-describedby since it is the same as the ' +
-        '@alt (used for name) and @title attributes',
+  desc: "No description from @aria-describedby since it is the same as the " +
+        "@alt (used for name) and @title attributes",
   attrs: [{
-    attr: 'aria-describedby',
-    value: 'description2'
+    attr: "aria-describedby",
+    value: "description2"
   }],
-  waitFor: [[EVENT_DESCRIPTION_CHANGE, 'image']],
-  expected: ''
+  waitFor: [[EVENT_DESCRIPTION_CHANGE, "image"]],
+  expected: ""
 }, {
-  desc: 'Description from @aria-describedby attribute when it is different ' +
-        'from @alt (used for name) and @title attributes',
+  desc: "Description from @aria-describedby attribute when it is different " +
+        "from @alt (used for name) and @title attributes",
   attrs: [{
-    attr: 'aria-describedby',
-    value: 'description'
+    attr: "aria-describedby",
+    value: "description"
   }],
-  waitFor: [[EVENT_DESCRIPTION_CHANGE, 'image']],
-  expected: 'aria description'
+  waitFor: [[EVENT_DESCRIPTION_CHANGE, "image"]],
+  expected: "aria description"
 }, {
-  desc: 'No description from @aria-describedby since it is the same as the ' +
-        '@alt attribute (used for name) but different from title',
+  desc: "No description from @aria-describedby since it is the same as the " +
+        "@alt attribute (used for name) but different from title",
   attrs: [{
-    attr: 'alt',
-    value: 'aria description'
+    attr: "alt",
+    value: "aria description"
   }],
-  waitFor: [[EVENT_NAME_CHANGE, 'image']],
-  expected: ''
+  waitFor: [[EVENT_NAME_CHANGE, "image"]],
+  expected: ""
 }, {
-  desc: 'Description from @aria-describedby attribute when @alt (used for ' +
-        'name) and @aria-describedby are not the same but @title and ' +
-        'aria-describedby are',
+  desc: "Description from @aria-describedby attribute when @alt (used for " +
+        "name) and @aria-describedby are not the same but @title and " +
+        "aria-describedby are",
   attrs: [{
-    attr: 'aria-describedby',
-    value: 'description2'
+    attr: "aria-describedby",
+    value: "description2"
   }],
-  waitFor: [[EVENT_DESCRIPTION_CHANGE, 'image']],
-  expected: 'another description'
+  waitFor: [[EVENT_DESCRIPTION_CHANGE, "image"]],
+  expected: "another description"
 }];
 
 /**
  * Test caching of accessible object description
  */
 addAccessibleTask(`
   <p id="description">aria description</p>
   <p id="description2">another description</p>
   <img id="image" />`,
   async function(browser, accDoc) {
-    let imgAcc = findAccessibleChildByID(accDoc, 'image');
+    let imgAcc = findAccessibleChildByID(accDoc, "image");
 
     for (let { desc, waitFor, attrs, expected } of tests) {
       info(desc);
       let onUpdate;
       if (waitFor) {
         onUpdate = waitForOrderedEvents(waitFor);
       }
       if (attrs) {
         for (let { attr, value } of attrs) {
-          await invokeSetAttribute(browser, 'image', attr, value);
+          await invokeSetAttribute(browser, "image", attr, value);
         }
       }
       await onUpdate;
       // When attribute change (alt) triggers reorder event, accessible will
       // become defunct.
       if (isDefunct(imgAcc)) {
-        imgAcc = findAccessibleChildByID(accDoc, 'image');
+        imgAcc = findAccessibleChildByID(accDoc, "image");
       }
       testDescr(imgAcc, expected);
     }
   }
 );
--- a/accessible/tests/browser/e10s/browser_caching_name.js
+++ b/accessible/tests/browser/e10s/browser_caching_name.js
@@ -1,16 +1,16 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/name.js */
-loadScripts({ name: 'name.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "name.js", dir: MOCHITESTS_DIR });
 
 /**
  * Rules for name tests that are inspired by
  *   accessible/tests/mochitest/name/markuprules.xul
  *
  * Each element in the list of rules represents a name calculation rule for a
  * particular test case.
  *
@@ -21,187 +21,187 @@ loadScripts({ name: 'name.js', dir: MOCH
  *
  *
  * Options include:
  *   * recreated   - subrtee is recreated and the test should only continue
  *                   after a reorder event
  *   * textchanged - text is inserted into a subtree and the test should only
  *                   continue after a text inserted event
  */
-const ARIARule = [{ attr: 'aria-labelledby' }, { attr: 'aria-label' }];
-const HTMLControlHeadRule = [...ARIARule, { elm: 'label', isSibling: true }];
+const ARIARule = [{ attr: "aria-labelledby" }, { attr: "aria-label" }];
+const HTMLControlHeadRule = [...ARIARule, { elm: "label", isSibling: true }];
 const rules = {
-  CSSContent: [{ elm: 'style', isSibling: true }, { fromsubtree: true }],
-  HTMLARIAGridCell: [...ARIARule, { fromsubtree: true }, { attr: 'title' }],
+  CSSContent: [{ elm: "style", isSibling: true }, { fromsubtree: true }],
+  HTMLARIAGridCell: [...ARIARule, { fromsubtree: true }, { attr: "title" }],
   HTMLControl: [...HTMLControlHeadRule, { fromsubtree: true },
-    { attr: 'title' }],
-  HTMLElm: [...ARIARule, { attr: 'title' }],
-  HTMLImg: [...ARIARule, { attr: 'alt', recreated: true }, { attr: 'title' }],
-  HTMLImgEmptyAlt: [...ARIARule, { attr: 'title' }, { attr: 'alt' }],
-  HTMLInputButton: [...HTMLControlHeadRule, { attr: 'value' },
-    { attr: 'title' }],
-  HTMLInputImage: [...HTMLControlHeadRule, { attr: 'alt', recreated: true },
-    { attr: 'value', recreated: true }, { attr: 'title' }],
+    { attr: "title" }],
+  HTMLElm: [...ARIARule, { attr: "title" }],
+  HTMLImg: [...ARIARule, { attr: "alt", recreated: true }, { attr: "title" }],
+  HTMLImgEmptyAlt: [...ARIARule, { attr: "title" }, { attr: "alt" }],
+  HTMLInputButton: [...HTMLControlHeadRule, { attr: "value" },
+    { attr: "title" }],
+  HTMLInputImage: [...HTMLControlHeadRule, { attr: "alt", recreated: true },
+    { attr: "value", recreated: true }, { attr: "title" }],
   HTMLInputImageNoValidSrc: [...HTMLControlHeadRule,
-    { attr: 'alt', recreated: true }, { attr: 'value', recreated: true }],
+    { attr: "alt", recreated: true }, { attr: "value", recreated: true }],
   HTMLInputReset: [...HTMLControlHeadRule,
-    { attr: 'value', textchanged: true }],
+    { attr: "value", textchanged: true }],
   HTMLInputSubmit: [...HTMLControlHeadRule,
-    { attr: 'value', textchanged: true }],
-  HTMLLink: [...ARIARule, { fromsubtree: true }, { attr: 'title' }],
-  HTMLLinkImage: [...ARIARule, { elm: 'img' }, { attr: 'title' }],
-  HTMLOption: [...ARIARule, { attr: 'label' }, { fromsubtree: true },
-    { attr: 'title' }],
-  HTMLTable: [...ARIARule, { elm: 'caption' }, { attr: 'summary' },
-    { attr: 'title' }]
+    { attr: "value", textchanged: true }],
+  HTMLLink: [...ARIARule, { fromsubtree: true }, { attr: "title" }],
+  HTMLLinkImage: [...ARIARule, { elm: "img" }, { attr: "title" }],
+  HTMLOption: [...ARIARule, { attr: "label" }, { fromsubtree: true },
+    { attr: "title" }],
+  HTMLTable: [...ARIARule, { elm: "caption" }, { attr: "summary" },
+    { attr: "title" }]
 };
 
 const markupTests = [{
-  id: 'btn',
-  ruleset: 'HTMLControl',
+  id: "btn",
+  ruleset: "HTMLControl",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <label for="btn">test4</label>
     <button id="btn"
             aria-label="test1"
             aria-labelledby="l1 l2"
             title="test5">press me</button>`,
-  expected: ['test2 test3', 'test1', 'test4', 'press me', 'test5']
+  expected: ["test2 test3", "test1", "test4", "press me", "test5"]
 }, {
-  id: 'btn',
-  ruleset: 'HTMLInputButton',
+  id: "btn",
+  ruleset: "HTMLInputButton",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <label for="btn">test4</label>
     <input id="btn"
            type="button"
            aria-label="test1"
            aria-labelledby="l1 l2"
            value="name from value"
            alt="no name from al"
            src="no name from src"
            data="no name from data"
            title="name from title"/>`,
-  expected: ['test2 test3', 'test1', 'test4', 'name from value',
-    'name from title']
+  expected: ["test2 test3", "test1", "test4", "name from value",
+    "name from title"]
 }, {
-  id: 'btn-submit',
-  ruleset: 'HTMLInputSubmit',
+  id: "btn-submit",
+  ruleset: "HTMLInputSubmit",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <label for="btn-submit">test4</label>
     <input id="btn-submit"
            type="submit"
            aria-label="test1"
            aria-labelledby="l1 l2"
            value="name from value"
            alt="no name from atl"
            src="no name from src"
            data="no name from data"
            title="no name from title"/>`,
-  expected: ['test2 test3', 'test1', 'test4', 'name from value']
+  expected: ["test2 test3", "test1", "test4", "name from value"]
 }, {
-  id: 'btn-reset',
-  ruleset: 'HTMLInputReset',
+  id: "btn-reset",
+  ruleset: "HTMLInputReset",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <label for="btn-reset">test4</label>
     <input id="btn-reset"
            type="reset"
            aria-label="test1"
            aria-labelledby="l1 l2"
            value="name from value"
            alt="no name from alt"
            src="no name from src"
            data="no name from data"
            title="no name from title"/>`,
-  expected: ['test2 test3', 'test1', 'test4', 'name from value']
+  expected: ["test2 test3", "test1", "test4", "name from value"]
 }, {
-  id: 'btn-image',
-  ruleset: 'HTMLInputImage',
+  id: "btn-image",
+  ruleset: "HTMLInputImage",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <label for="btn-image">test4</label>
     <input id="btn-image"
            type="image"
            aria-label="test1"
            aria-labelledby="l1 l2"
            alt="name from alt"
            value="name from value"
            src="http://example.com/a11y/accessible/tests/mochitest/moz.png"
            data="no name from data"
            title="name from title"/>`,
-  expected: ['test2 test3', 'test1', 'test4', 'name from alt',
-    'name from value', 'name from title']
+  expected: ["test2 test3", "test1", "test4", "name from alt",
+    "name from value", "name from title"]
 }, {
-  id: 'btn-image',
-  ruleset: 'HTMLInputImageNoValidSrc',
+  id: "btn-image",
+  ruleset: "HTMLInputImageNoValidSrc",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <label for="btn-image">test4</label>
     <input id="btn-image"
            type="image"
            aria-label="test1"
            aria-labelledby="l1 l2"
            alt="name from alt"
            value="name from value"
            data="no name from data"
            title="no name from title"/>`,
-  expected: ['test2 test3', 'test1', 'test4', 'name from alt',
-    'name from value']
+  expected: ["test2 test3", "test1", "test4", "name from alt",
+    "name from value"]
 }, {
-  id: 'opt',
-  ruleset: 'HTMLOption',
+  id: "opt",
+  ruleset: "HTMLOption",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <select>
       <option id="opt"
               aria-label="test1"
               aria-labelledby="l1 l2"
               label="test4"
               title="test5">option1</option>
       <option>option2</option>
     </select>`,
-  expected: ['test2 test3', 'test1', 'test4', 'option1', 'test5']
+  expected: ["test2 test3", "test1", "test4", "option1", "test5"]
 }, {
-  id: 'img',
-  ruleset: 'HTMLImg',
+  id: "img",
+  ruleset: "HTMLImg",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <img id="img"
          aria-label="Logo of Mozilla"
          aria-labelledby="l1 l2"
          alt="Mozilla logo"
          title="This is a logo"
          src="http://example.com/a11y/accessible/tests/mochitest/moz.png"/>`,
-  expected: ['test2 test3', 'Logo of Mozilla', 'Mozilla logo', 'This is a logo']
+  expected: ["test2 test3", "Logo of Mozilla", "Mozilla logo", "This is a logo"]
 }, {
-  id: 'imgemptyalt',
-  ruleset: 'HTMLImgEmptyAlt',
+  id: "imgemptyalt",
+  ruleset: "HTMLImgEmptyAlt",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <img id="imgemptyalt"
          aria-label="Logo of Mozilla"
          aria-labelledby="l1 l2"
          title="This is a logo"
          alt=""
          src="http://example.com/a11y/accessible/tests/mochitest/moz.png"/>`,
-  expected: ['test2 test3', 'Logo of Mozilla', 'This is a logo', '']
+  expected: ["test2 test3", "Logo of Mozilla", "This is a logo", ""]
 }, {
-  id: 'tc',
-  ruleset: 'HTMLElm',
+  id: "tc",
+  ruleset: "HTMLElm",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <label for="tc">test4</label>
     <table>
       <tr>
         <td id="tc"
             aria-label="test1"
@@ -210,20 +210,20 @@ const markupTests = [{
           <p>This is a paragraph</p>
           <a href="#">This is a link</a>
           <ul>
             <li>This is a list</li>
           </ul>
         </td>
       </tr>
     </table>`,
-  expected: ['test2 test3', 'test1', 'test5']
+  expected: ["test2 test3", "test1", "test5"]
 }, {
-  id: 'gc',
-  ruleset: 'HTMLARIAGridCell',
+  id: "gc",
+  ruleset: "HTMLARIAGridCell",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <label for="gc">test4</label>
     <table>
       <tr>
         <td id="gc"
             role="gridcell"
@@ -234,86 +234,86 @@ const markupTests = [{
           <a href="#">This is a link</a>
           <ul>
             <li>Listitem1</li>
             <li>Listitem2</li>
           </ul>
         </td>
       </tr>
     </table>`,
-  expected: ['test2 test3', 'test1',
-    'This is a paragraph This is a link \u2022 Listitem1 \u2022 Listitem2',
-    'This is a paragraph This is a link This is a list']
+  expected: ["test2 test3", "test1",
+    "This is a paragraph This is a link \u2022 Listitem1 \u2022 Listitem2",
+    "This is a paragraph This is a link This is a list"]
 }, {
-  id: 't',
-  ruleset: 'HTMLTable',
+  id: "t",
+  ruleset: "HTMLTable",
   markup: `
     <span id="l1">lby_tst6_1</span>
     <span id="l2">lby_tst6_2</span>
     <label for="t">label_tst6</label>
     <table id="t"
            aria-label="arialabel_tst6"
            aria-labelledby="l1 l2"
            summary="summary_tst6"
            title="title_tst6">
       <caption>caption_tst6</caption>
       <tr>
         <td>cell1</td>
         <td>cell2</td>
       </tr>
     </table>`,
-  expected: ['lby_tst6_1 lby_tst6_2', 'arialabel_tst6', 'caption_tst6',
-    'summary_tst6', 'title_tst6']
+  expected: ["lby_tst6_1 lby_tst6_2", "arialabel_tst6", "caption_tst6",
+    "summary_tst6", "title_tst6"]
 }, {
-  id: 'btn',
-  ruleset: 'CSSContent',
+  id: "btn",
+  ruleset: "CSSContent",
   markup: `
     <style>
       button::before {
         content: "do not ";
       }
     </style>
     <button id="btn">press me</button>`,
-  expected: ['do not press me', 'press me']
+  expected: ["do not press me", "press me"]
 }, {
   // TODO: uncomment when Bug-1256382 is resoved.
   // id: 'li',
   // ruleset: 'CSSContent',
   // markup: `
   //   <style>
   //     ul {
   //       list-style-type: decimal;
   //     }
   //   </style>
   //   <ul id="ul">
   //     <li id="li">Listitem</li>
   //   </ul>`,
   // expected: ['1. Listitem', `${String.fromCharCode(0x2022)} Listitem`]
 // }, {
-  id: 'a',
-  ruleset: 'HTMLLink',
+  id: "a",
+  ruleset: "HTMLLink",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <a id="a"
        aria-label="test1"
        aria-labelledby="l1 l2"
        title="test4">test5</a>`,
-  expected: ['test2 test3', 'test1', 'test5', 'test4']
+  expected: ["test2 test3", "test1", "test5", "test4"]
 }, {
-  id: 'a-img',
-  ruleset: 'HTMLLinkImage',
+  id: "a-img",
+  ruleset: "HTMLLinkImage",
   markup: `
     <span id="l1">test2</span>
     <span id="l2">test3</span>
     <a id="a-img"
        aria-label="test1"
        aria-labelledby="l1 l2"
        title="test4"><img alt="test5"/></a>`,
-  expected: ['test2 test3', 'test1', 'test5', 'test4']
+  expected: ["test2 test3", "test1", "test5", "test4"]
 }];
 
 /**
  * Wait for an accessible event to happen and, in case given accessible is
  * defunct, update it to one that is attached to the accessible event.
  * @param {Promise} onEvent      accessible event promise
  * @param {Object}  target       { acc, parent, id } structure that contains an
  *                                accessible, its parent and its content element
--- a/accessible/tests/browser/e10s/browser_caching_relations.js
+++ b/accessible/tests/browser/e10s/browser_caching_relations.js
@@ -1,69 +1,69 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/relations.js */
-loadScripts({ name: 'relations.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "relations.js", dir: MOCHITESTS_DIR });
 
 /**
  * A test specification that has the following format:
  * [
  *   attr                 relevant aria attribute
  *   hostRelation         corresponding host relation type
  *   dependantRelation    corresponding dependant relation type
  * ]
  */
 const attrRelationsSpec = [
-  ['aria-labelledby', RELATION_LABELLED_BY, RELATION_LABEL_FOR],
-  ['aria-describedby', RELATION_DESCRIBED_BY, RELATION_DESCRIPTION_FOR],
-  ['aria-controls', RELATION_CONTROLLER_FOR, RELATION_CONTROLLED_BY],
-  ['aria-flowto', RELATION_FLOWS_TO, RELATION_FLOWS_FROM]
+  ["aria-labelledby", RELATION_LABELLED_BY, RELATION_LABEL_FOR],
+  ["aria-describedby", RELATION_DESCRIBED_BY, RELATION_DESCRIPTION_FOR],
+  ["aria-controls", RELATION_CONTROLLER_FOR, RELATION_CONTROLLED_BY],
+  ["aria-flowto", RELATION_FLOWS_TO, RELATION_FLOWS_FROM]
 ];
 
 async function testRelated(browser, accDoc, attr, hostRelation, dependantRelation) {
-  let host = findAccessibleChildByID(accDoc, 'host');
-  let dependant1 = findAccessibleChildByID(accDoc, 'dependant1');
-  let dependant2 = findAccessibleChildByID(accDoc, 'dependant2');
+  let host = findAccessibleChildByID(accDoc, "host");
+  let dependant1 = findAccessibleChildByID(accDoc, "dependant1");
+  let dependant2 = findAccessibleChildByID(accDoc, "dependant2");
 
   /**
    * Test data has the format of:
    * {
    *   desc      {String}   description for better logging
    *   attrs     {?Array}   an optional list of attributes to update
    *   expected  {Array}    expected relation values for dependant1, dependant2
    *                        and host respectively.
    * }
    */
   const tests = [{
-    desc: 'No attribute',
+    desc: "No attribute",
     expected: [ null, null, null ]
   }, {
-    desc: 'Set attribute',
-    attrs: [{ key: attr, value: 'dependant1' }],
+    desc: "Set attribute",
+    attrs: [{ key: attr, value: "dependant1" }],
     expected: [ host, null, dependant1 ]
   }, {
-    desc: 'Change attribute',
-    attrs: [{ key: attr, value: 'dependant2' }],
+    desc: "Change attribute",
+    attrs: [{ key: attr, value: "dependant2" }],
     expected: [ null, host, dependant2 ]
   }, {
-    desc: 'Remove attribute',
+    desc: "Remove attribute",
     attrs: [{ key: attr }],
     expected: [ null, null, null ]
   }];
 
   for (let { desc, attrs, expected } of tests) {
     info(desc);
 
     if (attrs) {
       for (let { key, value } of attrs) {
-        await invokeSetAttribute(browser, 'host', key, value);
+        await invokeSetAttribute(browser, "host", key, value);
       }
     }
 
     testRelation(dependant1, dependantRelation, expected[0]);
     testRelation(dependant2, dependantRelation, expected[1]);
     testRelation(host, hostRelation, expected[2]);
   }
 }
--- a/accessible/tests/browser/e10s/browser_caching_states.js
+++ b/accessible/tests/browser/e10s/browser_caching_states.js
@@ -1,18 +1,18 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
 /* import-globals-from ../../mochitest/states.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR },
-            { name: 'states.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR },
+            { name: "states.js", dir: MOCHITESTS_DIR });
 
 /**
  * Test data has the format of:
  * {
  *   desc      {String}   description for better logging
  *   expected  {Array}    expected states for a given accessible that have the
  *                        following format:
  *                          [
@@ -22,76 +22,76 @@ loadScripts({ name: 'role.js', dir: MOCH
  *                            absent extra state
  *                          ]
  *   attrs     {?Array}   an optional list of attributes to update
  * }
  */
 
 // State caching tests for attribute changes
 const attributeTests = [{
-  desc: 'Checkbox with @checked attribute set to true should have checked ' +
-        'state',
+  desc: "Checkbox with @checked attribute set to true should have checked " +
+        "state",
   attrs: [{
-    attr: 'checked',
-    value: 'true'
+    attr: "checked",
+    value: "true"
   }],
   expected: [STATE_CHECKED, 0]
 }, {
-  desc: 'Checkbox with no @checked attribute should not have checked state',
+  desc: "Checkbox with no @checked attribute should not have checked state",
   attrs: [{
-    attr: 'checked'
+    attr: "checked"
   }],
   expected: [0, 0, STATE_CHECKED]
 }];
 
 // State caching tests for ARIA changes
 const ariaTests = [{
-  desc: 'File input has busy state when @aria-busy attribute is set to true',
+  desc: "File input has busy state when @aria-busy attribute is set to true",
   attrs: [{
-    attr: 'aria-busy',
-    value: 'true'
+    attr: "aria-busy",
+    value: "true"
   }],
   expected: [STATE_BUSY, 0, STATE_REQUIRED | STATE_INVALID]
 }, {
-  desc: 'File input has required state when @aria-required attribute is set ' +
-        'to true',
+  desc: "File input has required state when @aria-required attribute is set " +
+        "to true",
   attrs: [{
-    attr: 'aria-required',
-    value: 'true'
+    attr: "aria-required",
+    value: "true"
   }],
   expected: [STATE_REQUIRED, 0, STATE_INVALID]
 }, {
-  desc: 'File input has invalid state when @aria-invalid attribute is set to ' +
-        'true',
+  desc: "File input has invalid state when @aria-invalid attribute is set to " +
+        "true",
   attrs: [{
-    attr: 'aria-invalid',
-    value: 'true'
+    attr: "aria-invalid",
+    value: "true"
   }],
   expected: [STATE_INVALID, 0]
 }];
 
 // Extra state caching tests
 const extraStateTests = [{
-  desc: 'Input has no extra enabled state when aria and native disabled ' +
-        'attributes are set at once',
+  desc: "Input has no extra enabled state when aria and native disabled " +
+        "attributes are set at once",
   attrs: [{
-    attr: 'aria-disabled',
-    value: 'true'
+    attr: "aria-disabled",
+    value: "true"
   }, {
-    attr: 'disabled',
-    value: 'true'
+    attr: "disabled",
+    value: "true"
   }],
   expected: [0, 0, 0, EXT_STATE_ENABLED]
 }, {
-  desc: 'Input has an extra enabled state when aria and native disabled ' +
-        'attributes are unset at once',
+  desc: "Input has an extra enabled state when aria and native disabled " +
+        "attributes are unset at once",
   attrs: [{
-    attr: 'aria-disabled'
+    attr: "aria-disabled"
   }, {
-    attr: 'disabled'
+    attr: "disabled"
   }],
   expected: [0, EXT_STATE_ENABLED]
 }];
 
 async function runStateTests(browser, accDoc, id, tests) {
   let acc = findAccessibleChildByID(accDoc, id);
   for (let { desc, attrs, expected } of tests) {
     info(desc);
@@ -107,13 +107,13 @@ async function runStateTests(browser, ac
 /**
  * Test caching of accessible object states
  */
 addAccessibleTask(`
   <input id="checkbox" type="checkbox">
   <input id="file" type="file">
   <input id="text">`,
   async function (browser, accDoc) {
-    await runStateTests(browser, accDoc, 'checkbox', attributeTests);
-    await runStateTests(browser, accDoc, 'file', ariaTests);
-    await runStateTests(browser, accDoc, 'text', extraStateTests);
+    await runStateTests(browser, accDoc, "checkbox", attributeTests);
+    await runStateTests(browser, accDoc, "file", ariaTests);
+    await runStateTests(browser, accDoc, "text", extraStateTests);
   }
 );
--- a/accessible/tests/browser/e10s/browser_caching_value.js
+++ b/accessible/tests/browser/e10s/browser_caching_value.js
@@ -1,118 +1,118 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/value.js */
-loadScripts({ name: 'value.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "value.js", dir: MOCHITESTS_DIR });
 
 /**
  * Test data has the format of:
  * {
  *   desc      {String}            description for better logging
  *   id        {String}            given accessible DOMNode ID
  *   expected  {String}            expected value for a given accessible
  *   action    {?AsyncFunction}    an optional action that awaits a value change
  *   attrs     {?Array}            an optional list of attributes to update
  *   waitFor   {?Number}           an optional value change event to wait for
  * }
  */
 const valueTests = [{
-  desc: 'Initially value is set to 1st element of select',
-  id: 'select',
-  expected: '1st'
+  desc: "Initially value is set to 1st element of select",
+  id: "select",
+  expected: "1st"
 }, {
-  desc: 'Value should update to 3rd when 3 is pressed',
-  id: 'select',
+  desc: "Value should update to 3rd when 3 is pressed",
+  id: "select",
   action: async function(browser) {
-    await invokeFocus(browser, 'select');
-    await BrowserTestUtils.synthesizeKey('3', {}, browser);
+    await invokeFocus(browser, "select");
+    await BrowserTestUtils.synthesizeKey("3", {}, browser);
   },
   waitFor: EVENT_TEXT_VALUE_CHANGE,
-  expected: '3rd'
+  expected: "3rd"
 }, {
-  desc: 'Initially value is set to @aria-valuenow for slider',
-  id: 'slider',
-  expected: ['5', 5, 0, 7, 0]
+  desc: "Initially value is set to @aria-valuenow for slider",
+  id: "slider",
+  expected: ["5", 5, 0, 7, 0]
 }, {
-  desc: 'Value should change when @aria-valuenow is updated',
-  id: 'slider',
+  desc: "Value should change when @aria-valuenow is updated",
+  id: "slider",
   attrs: [{
-    attr: 'aria-valuenow',
-    value: '6'
+    attr: "aria-valuenow",
+    value: "6"
   }],
   waitFor: EVENT_VALUE_CHANGE,
-  expected: ['6', 6, 0, 7, 0]
+  expected: ["6", 6, 0, 7, 0]
 }, {
-  desc: 'Value should change when @aria-valuetext is set',
-  id: 'slider',
+  desc: "Value should change when @aria-valuetext is set",
+  id: "slider",
   attrs: [{
-    attr: 'aria-valuetext',
-    value: 'plain'
+    attr: "aria-valuetext",
+    value: "plain"
   }],
   waitFor: EVENT_TEXT_VALUE_CHANGE,
-  expected: ['plain', 6, 0, 7, 0]
+  expected: ["plain", 6, 0, 7, 0]
 }, {
-  desc: 'Value should change when @aria-valuetext is updated',
-  id: 'slider',
+  desc: "Value should change when @aria-valuetext is updated",
+  id: "slider",
   attrs: [{
-    attr: 'aria-valuetext',
-    value: 'hey!'
+    attr: "aria-valuetext",
+    value: "hey!"
   }],
   waitFor: EVENT_TEXT_VALUE_CHANGE,
-  expected: ['hey!', 6, 0, 7, 0]
+  expected: ["hey!", 6, 0, 7, 0]
 }, {
-  desc: 'Value should change to @aria-valuetext when @aria-valuenow is removed',
-  id: 'slider',
+  desc: "Value should change to @aria-valuetext when @aria-valuenow is removed",
+  id: "slider",
   attrs: [{
-    attr: 'aria-valuenow'
+    attr: "aria-valuenow"
   }],
-  expected: ['hey!', 0, 0, 7, 0]
+  expected: ["hey!", 0, 0, 7, 0]
 }, {
-  desc: 'Initially value is not set for combobox',
-  id: 'combobox',
-  expected: ''
+  desc: "Initially value is not set for combobox",
+  id: "combobox",
+  expected: ""
 }, {
-  desc: 'Value should change when @value attribute is updated',
-  id: 'combobox',
+  desc: "Value should change when @value attribute is updated",
+  id: "combobox",
   attrs: [{
-    attr: 'value',
-    value: 'hello'
+    attr: "value",
+    value: "hello"
   }],
   waitFor: EVENT_TEXT_VALUE_CHANGE,
-  expected: 'hello'
+  expected: "hello"
 }, {
-  desc: 'Initially value corresponds to @value attribute for progress',
-  id: 'progress',
-  expected: '22%'
+  desc: "Initially value corresponds to @value attribute for progress",
+  id: "progress",
+  expected: "22%"
 }, {
-  desc: 'Value should change when @value attribute is updated',
-  id: 'progress',
+  desc: "Value should change when @value attribute is updated",
+  id: "progress",
   attrs: [{
-    attr: 'value',
-    value: '50'
+    attr: "value",
+    value: "50"
   }],
   waitFor: EVENT_VALUE_CHANGE,
-  expected: '50%'
+  expected: "50%"
 }, {
-  desc: 'Initially value corresponds to @value attribute for range',
-  id: 'range',
-  expected: '6'
+  desc: "Initially value corresponds to @value attribute for range",
+  id: "range",
+  expected: "6"
 }, {
-  desc: 'Value should change when slider is moved',
-  id: 'range',
+  desc: "Value should change when slider is moved",
+  id: "range",
   action: async function(browser) {
-    await invokeFocus(browser, 'range');
-    await BrowserTestUtils.synthesizeKey('VK_LEFT', {}, browser);
+    await invokeFocus(browser, "range");
+    await BrowserTestUtils.synthesizeKey("VK_LEFT", {}, browser);
   },
   waitFor: EVENT_VALUE_CHANGE,
-  expected: '5'
+  expected: "5"
 }];
 
 /**
  * Test caching of accessible object values
  */
 addAccessibleTask(`
   <div id="slider" role="slider" aria-valuenow="5"
        aria-valuemin="0" aria-valuemax="7">slider</div>
--- a/accessible/tests/browser/e10s/browser_events_caretmove.js
+++ b/accessible/tests/browser/e10s/browser_events_caretmove.js
@@ -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';
+"use strict";
 
 /**
  * Test caret move event and its interface:
  *   - caretOffset
  */
 addAccessibleTask('<input id="textbox" value="hello"/>', async function(browser) {
-  let onCaretMoved = waitForEvent(EVENT_TEXT_CARET_MOVED, 'textbox');
-  await invokeFocus(browser, 'textbox');
+  let onCaretMoved = waitForEvent(EVENT_TEXT_CARET_MOVED, "textbox");
+  await invokeFocus(browser, "textbox");
   let event = await onCaretMoved;
 
   let caretMovedEvent = event.QueryInterface(nsIAccessibleCaretMoveEvent);
   is(caretMovedEvent.caretOffset, 5,
-    'Correct caret offset.');
+    "Correct caret offset.");
 });
--- a/accessible/tests/browser/e10s/browser_events_hide.js
+++ b/accessible/tests/browser/e10s/browser_events_hide.js
@@ -1,33 +1,33 @@
 /* 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';
+"use strict";
 
 /**
  * Test hide event and its interface:
  *   - targetParent
  *   - targetNextSibling
  *   - targetPrevSibling
  */
 addAccessibleTask(`
   <div id="parent">
     <div id="previous"></div>
     <div id="to-hide"></div>
     <div id="next"></div>
   </div>`,
   async function(browser, accDoc) {
-    let acc = findAccessibleChildByID(accDoc, 'to-hide');
+    let acc = findAccessibleChildByID(accDoc, "to-hide");
     let onHide = waitForEvent(EVENT_HIDE, acc);
-    await invokeSetStyle(browser, 'to-hide', 'visibility', 'hidden');
+    await invokeSetStyle(browser, "to-hide", "visibility", "hidden");
     let event = await onHide;
     let hideEvent = event.QueryInterface(Ci.nsIAccessibleHideEvent);
 
-    is(getAccessibleDOMNodeID(hideEvent.targetParent), 'parent',
-      'Correct target parent.');
-    is(getAccessibleDOMNodeID(hideEvent.targetNextSibling), 'next',
-      'Correct target next sibling.');
-    is(getAccessibleDOMNodeID(hideEvent.targetPrevSibling), 'previous',
-      'Correct target previous sibling.');
+    is(getAccessibleDOMNodeID(hideEvent.targetParent), "parent",
+      "Correct target parent.");
+    is(getAccessibleDOMNodeID(hideEvent.targetNextSibling), "next",
+      "Correct target next sibling.");
+    is(getAccessibleDOMNodeID(hideEvent.targetPrevSibling), "previous",
+      "Correct target previous sibling.");
   }
 );
--- a/accessible/tests/browser/e10s/browser_events_show.js
+++ b/accessible/tests/browser/e10s/browser_events_show.js
@@ -1,15 +1,15 @@
 /* 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';
+"use strict";
 
 /**
  * Test show event
  */
 addAccessibleTask('<div id="div" style="visibility: hidden;"></div>',
   async function(browser) {
-    let onShow = waitForEvent(EVENT_SHOW, 'div');
-    await invokeSetStyle(browser, 'div', 'visibility', 'visible');
+    let onShow = waitForEvent(EVENT_SHOW, "div");
+    await invokeSetStyle(browser, "div", "visibility", "visible");
     await onShow;
   });
--- a/accessible/tests/browser/e10s/browser_events_statechange.js
+++ b/accessible/tests/browser/e10s/browser_events_statechange.js
@@ -1,25 +1,25 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
 /* import-globals-from ../../mochitest/states.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR },
-            { name: 'states.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR },
+            { name: "states.js", dir: MOCHITESTS_DIR });
 
 function checkStateChangeEvent(event, state, isExtraState, isEnabled) {
   let scEvent = event.QueryInterface(nsIAccessibleStateChangeEvent);
-  is(scEvent.state, state, 'Correct state of the statechange event.');
+  is(scEvent.state, state, "Correct state of the statechange event.");
   is(scEvent.isExtraState, isExtraState,
-    'Correct extra state bit of the statechange event.');
-  is(scEvent.isEnabled, isEnabled, 'Correct state of statechange event state');
+    "Correct extra state bit of the statechange event.");
+  is(scEvent.isEnabled, isEnabled, "Correct state of statechange event state");
 }
 
 // Insert mock source into the iframe to be able to verify the right document
 // body id.
 let iframeSrc = `data:text/html,
   <html>
     <head>
       <meta charset='utf-8'/>
@@ -33,29 +33,29 @@ let iframeSrc = `data:text/html,
  *   - state
  *   - isExtraState
  *   - isEnabled
  */
 addAccessibleTask(`
   <iframe id="iframe" src="${iframeSrc}"></iframe>
   <input id="checkbox" type="checkbox" />`, async function(browser) {
   // Test state change
-  let onStateChange = waitForEvent(EVENT_STATE_CHANGE, 'checkbox');
+  let onStateChange = waitForEvent(EVENT_STATE_CHANGE, "checkbox");
   // Set checked for a checkbox.
   await ContentTask.spawn(browser, {}, () => {
-    content.document.getElementById('checkbox').checked = true;
+    content.document.getElementById("checkbox").checked = true;
   });
   let event = await onStateChange;
 
   checkStateChangeEvent(event, STATE_CHECKED, false, true);
   testStates(event.accessible, STATE_CHECKED, 0);
 
   // Test extra state
-  onStateChange = waitForEvent(EVENT_STATE_CHANGE, 'iframe');
+  onStateChange = waitForEvent(EVENT_STATE_CHANGE, "iframe");
   // Set design mode on.
   await ContentTask.spawn(browser, {}, () => {
-    content.document.getElementById('iframe').contentDocument.designMode = 'on';
+    content.document.getElementById("iframe").contentDocument.designMode = "on";
   });
   event = await onStateChange;
 
   checkStateChangeEvent(event, EXT_STATE_EDITABLE, true, true);
   testStates(event.accessible, 0, EXT_STATE_EDITABLE);
 });
--- a/accessible/tests/browser/e10s/browser_events_textchange.js
+++ b/accessible/tests/browser/e10s/browser_events_textchange.js
@@ -1,13 +1,13 @@
 /* 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';
+"use strict";
 
 function checkTextChangeEvent(event, id, text, start, end, isInserted, isFromUserInput) {
   let tcEvent = event.QueryInterface(nsIAccessibleTextChangeEvent);
   is(tcEvent.start, start, `Correct start offset for ${prettyName(id)}`);
   is(tcEvent.length, end - start, `Correct length for ${prettyName(id)}`);
   is(tcEvent.isInserted, isInserted,
     `Correct isInserted flag for ${prettyName(id)}`);
   is(tcEvent.modifiedText, text, `Correct text for ${prettyName(id)}`);
@@ -35,17 +35,17 @@ async function changeText(browser, id, v
 async function removeTextFromInput(browser, id, value, start, end) {
   let onTextRemoved = waitForEvent(EVENT_TEXT_REMOVED, id);
   // Select text and delete it.
   await ContentTask.spawn(browser, [id, start, end], ([contentId, contentStart, contentEnd]) => {
     let el = content.document.getElementById(contentId);
     el.focus();
     el.setSelectionRange(contentStart, contentEnd);
   });
-  await BrowserTestUtils.sendChar('VK_DELETE', browser);
+  await BrowserTestUtils.sendChar("VK_DELETE", browser);
 
   let event = await onTextRemoved;
   checkTextChangeEvent(event, id, value, start, end, false, true);
 }
 
 /**
  * Test text change event and its interface:
  *   - start
@@ -53,19 +53,19 @@ async function removeTextFromInput(brows
  *   - isInserted
  *   - modifiedText
  *   - isFromUserInput
  */
 addAccessibleTask(`
   <p id="p">abc</p>
   <input id="input" value="input" />`, async function(browser) {
   let events = [
-    { isInserted: false, str: 'abc', offset: 0 },
-    { isInserted: true, str: 'def', offset: 0 }
+    { isInserted: false, str: "abc", offset: 0 },
+    { isInserted: true, str: "def", offset: 0 }
   ];
-  await changeText(browser, 'p', 'def', events);
+  await changeText(browser, "p", "def", events);
 
-  events = [{ isInserted: true, str: 'DEF', offset: 2 }];
-  await changeText(browser, 'p', 'deDEFf', events);
+  events = [{ isInserted: true, str: "DEF", offset: 2 }];
+  await changeText(browser, "p", "deDEFf", events);
 
   // Test isFromUserInput property.
-  await removeTextFromInput(browser, 'input', 'n', 1, 2);
+  await removeTextFromInput(browser, "input", "n", 1, 2);
 });
--- a/accessible/tests/browser/e10s/browser_treeupdate_ariadialog.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_ariadialog.js
@@ -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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 // Test ARIA Dialog
-addAccessibleTask('doc_treeupdate_ariadialog.html', async function(browser, accDoc) {
+addAccessibleTask("doc_treeupdate_ariadialog.html", async function(browser, accDoc) {
   testAccessibleTree(accDoc, {
     role: ROLE_DOCUMENT,
     children: [ ]
   });
 
   // Make dialog visible and update its inner content.
-  let onShow = waitForEvent(EVENT_SHOW, 'dialog');
+  let onShow = waitForEvent(EVENT_SHOW, "dialog");
   await ContentTask.spawn(browser, {}, () => {
-    content.document.getElementById('dialog').style.display = 'block';
+    content.document.getElementById("dialog").style.display = "block";
   });
   await onShow;
 
   testAccessibleTree(accDoc, {
     role: ROLE_DOCUMENT,
     children: [
       {
         role: ROLE_DIALOG,
--- a/accessible/tests/browser/e10s/browser_treeupdate_ariaowns.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_ariaowns.js
@@ -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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 async function testContainer1(browser, accDoc) {
-  const id = 't1_container';
+  const id = "t1_container";
   const docID = getAccessibleDOMNodeID(accDoc);
   const acc = findAccessibleChildByID(accDoc, id);
 
   /* ================= Initial tree test ==================================== */
   // children are swapped by ARIA owns
   let tree = {
     SECTION: [
       { CHECKBUTTON: [
@@ -21,66 +21,66 @@ async function testContainer1(browser, a
       ] },
       { PUSHBUTTON: [ ] }
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================ Change ARIA owns ====================================== */
   let onReorder = waitForEvent(EVENT_REORDER, id);
-  await invokeSetAttribute(browser, id, 'aria-owns', 't1_button t1_subdiv');
+  await invokeSetAttribute(browser, id, "aria-owns", "t1_button t1_subdiv");
   await onReorder;
 
   // children are swapped again, button and subdiv are appended to
   // the children.
   tree = {
     SECTION: [
       { CHECKBUTTON: [ ] }, // checkbox, native order
       { PUSHBUTTON: [ ] }, // button, rearranged by ARIA own
       { SECTION: [ ] } // subdiv from the subtree, ARIA owned
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================ Remove ARIA owns ====================================== */
   onReorder = waitForEvent(EVENT_REORDER, id);
-  await invokeSetAttribute(browser, id, 'aria-owns');
+  await invokeSetAttribute(browser, id, "aria-owns");
   await onReorder;
 
   // children follow the DOM order
   tree = {
     SECTION: [
       { PUSHBUTTON: [ ] },
       { CHECKBUTTON: [
           { SECTION: [] }
       ] }
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================ Set ARIA owns ========================================= */
   onReorder = waitForEvent(EVENT_REORDER, id);
-  await invokeSetAttribute(browser, id, 'aria-owns', 't1_button t1_subdiv');
+  await invokeSetAttribute(browser, id, "aria-owns", "t1_button t1_subdiv");
   await onReorder;
 
   // children are swapped again, button and subdiv are appended to
   // the children.
   tree = {
     SECTION: [
       { CHECKBUTTON: [ ] }, // checkbox
       { PUSHBUTTON: [ ] }, // button, rearranged by ARIA own
       { SECTION: [ ] } // subdiv from the subtree, ARIA owned
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================ Add ID to ARIA owns =================================== */
   onReorder = waitForEvent(EVENT_REORDER, docID);
-  await invokeSetAttribute(browser, id, 'aria-owns',
-    't1_button t1_subdiv t1_group');
+  await invokeSetAttribute(browser, id, "aria-owns",
+    "t1_button t1_subdiv t1_group");
   await onReorder;
 
   // children are swapped again, button and subdiv are appended to
   // the children.
   tree = {
     SECTION: [
       { CHECKBUTTON: [ ] }, // t1_checkbox
       { PUSHBUTTON: [ ] }, // button, t1_button
@@ -88,19 +88,19 @@ async function testContainer1(browser, a
       { GROUPING: [ ] } // group from outside, t1_group
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================ Append element ======================================== */
   onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
-    let div = content.document.createElement('div');
-    div.setAttribute('id', 't1_child3');
-    div.setAttribute('role', 'radio');
+    let div = content.document.createElement("div");
+    div.setAttribute("id", "t1_child3");
+    div.setAttribute("role", "radio");
     content.document.getElementById(contentId).appendChild(div);
   });
   await onReorder;
 
   // children are invalidated, they includes aria-owns swapped kids and
   // newly inserted child.
   tree = {
     SECTION: [
@@ -111,92 +111,92 @@ async function testContainer1(browser, a
       { GROUPING: [ ] } // ARIA owned, t1_group
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================ Remove element ======================================== */
   onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, {}, () =>
-    content.document.getElementById('t1_span').remove());
+    content.document.getElementById("t1_span").remove());
   await onReorder;
 
   // subdiv should go away
   tree = {
     SECTION: [
       { CHECKBUTTON: [ ] }, // explicit, t1_checkbox
       { RADIOBUTTON: [ ] }, // explicit, t1_child3
       { PUSHBUTTON: [ ] }, // ARIA owned, t1_button
       { GROUPING: [ ] } // ARIA owned, t1_group
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================ Remove ID ============================================= */
   onReorder = waitForEvent(EVENT_REORDER, docID);
-  await invokeSetAttribute(browser, 't1_group', 'id');
+  await invokeSetAttribute(browser, "t1_group", "id");
   await onReorder;
 
   tree = {
     SECTION: [
       { CHECKBUTTON: [ ] },
       { RADIOBUTTON: [ ] },
       { PUSHBUTTON: [ ] } // ARIA owned, t1_button
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================ Set ID ================================================ */
   onReorder = waitForEvent(EVENT_REORDER, docID);
-  await invokeSetAttribute(browser, 't1_grouptmp', 'id', 't1_group');
+  await invokeSetAttribute(browser, "t1_grouptmp", "id", "t1_group");
   await onReorder;
 
   tree = {
     SECTION: [
       { CHECKBUTTON: [ ] },
       { RADIOBUTTON: [ ] },
       { PUSHBUTTON: [ ] }, // ARIA owned, t1_button
       { GROUPING: [ ] } // ARIA owned, t1_group, previously t1_grouptmp
     ]
   };
   testAccessibleTree(acc, tree);
 }
 
 async function removeContainer(browser, accDoc) {
-  const id = 't2_container1';
+  const id = "t2_container1";
   const acc = findAccessibleChildByID(accDoc, id);
 
   let tree = {
     SECTION: [
       { CHECKBUTTON: [ ] } // ARIA owned, 't2_owned'
     ]
   };
   testAccessibleTree(acc, tree);
 
   let onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, {}, () =>
-    content.document.getElementById('t2_container2').removeChild(
-      content.document.getElementById('t2_container3')));
+    content.document.getElementById("t2_container2").removeChild(
+      content.document.getElementById("t2_container3")));
   await onReorder;
 
   tree = {
     SECTION: [ ]
   };
   testAccessibleTree(acc, tree);
 }
 
 async function stealAndRecacheChildren(browser, accDoc) {
-  const id1 = 't3_container1';
-  const id2 = 't3_container2';
+  const id1 = "t3_container1";
+  const id2 = "t3_container2";
   const acc1 = findAccessibleChildByID(accDoc, id1);
   const acc2 = findAccessibleChildByID(accDoc, id2);
 
   /* ================ Steal from other ARIA owns ============================ */
   let onReorder = waitForEvent(EVENT_REORDER, id2);
-  await invokeSetAttribute(browser, id2, 'aria-owns', 't3_child');
+  await invokeSetAttribute(browser, id2, "aria-owns", "t3_child");
   await onReorder;
 
   let tree = {
     SECTION: [ ]
   };
   testAccessibleTree(acc1, tree);
 
   tree = {
@@ -204,18 +204,18 @@ async function stealAndRecacheChildren(b
       { CHECKBUTTON: [ ] }
     ]
   };
   testAccessibleTree(acc2, tree);
 
   /* ================ Append element to recache children ==================== */
   onReorder = waitForEvent(EVENT_REORDER, id2);
   await ContentTask.spawn(browser, id2, id => {
-    let div = content.document.createElement('div');
-    div.setAttribute('role', 'radio');
+    let div = content.document.createElement("div");
+    div.setAttribute("role", "radio");
     content.document.getElementById(id).appendChild(div);
   });
   await onReorder;
 
   tree = {
     SECTION: [ ]
   };
   testAccessibleTree(acc1, tree);
@@ -225,92 +225,92 @@ async function stealAndRecacheChildren(b
       { RADIOBUTTON: [ ] },
       { CHECKBUTTON: [ ] } // ARIA owned
     ]
   };
   testAccessibleTree(acc2, tree);
 }
 
 async function showHiddenElement(browser, accDoc) {
-  const id = 't4_container1';
+  const id = "t4_container1";
   const acc = findAccessibleChildByID(accDoc, id);
 
   let tree = {
     SECTION: [
       { RADIOBUTTON: [] }
     ]
   };
   testAccessibleTree(acc, tree);
 
   let onReorder = waitForEvent(EVENT_REORDER, id);
-  await invokeSetStyle(browser, 't4_child1', 'display', 'block');
+  await invokeSetStyle(browser, "t4_child1", "display", "block");
   await onReorder;
 
   tree = {
     SECTION: [
       { CHECKBUTTON: [] },
       { RADIOBUTTON: [] }
     ]
   };
   testAccessibleTree(acc, tree);
 }
 
 async function rearrangeARIAOwns(browser, accDoc) {
-  const id = 't5_container';
+  const id = "t5_container";
   const acc = findAccessibleChildByID(accDoc, id);
   const tests = [{
-    val: 't5_checkbox t5_radio t5_button',
-    roleList: [ 'CHECKBUTTON', 'RADIOBUTTON', 'PUSHBUTTON' ]
+    val: "t5_checkbox t5_radio t5_button",
+    roleList: [ "CHECKBUTTON", "RADIOBUTTON", "PUSHBUTTON" ]
   }, {
-    val: 't5_radio t5_button t5_checkbox',
-    roleList: [ 'RADIOBUTTON', 'PUSHBUTTON', 'CHECKBUTTON' ]
+    val: "t5_radio t5_button t5_checkbox",
+    roleList: [ "RADIOBUTTON", "PUSHBUTTON", "CHECKBUTTON" ]
   }];
 
   for (let { val, roleList } of tests) {
     let onReorder = waitForEvent(EVENT_REORDER, id);
-    await invokeSetAttribute(browser, id, 'aria-owns', val);
+    await invokeSetAttribute(browser, id, "aria-owns", val);
     await onReorder;
 
     let tree = { SECTION: [ ] };
     for (let role of roleList) {
       let ch = {};
       ch[role] = [];
       tree.SECTION.push(ch);
     }
     testAccessibleTree(acc, tree);
   }
 }
 
 async function removeNotARIAOwnedEl(browser, accDoc) {
-  const id = 't6_container';
+  const id = "t6_container";
   const acc = findAccessibleChildByID(accDoc, id);
 
   let tree = {
     SECTION: [
       { TEXT_LEAF: [ ] },
       { GROUPING: [ ] }
     ]
   };
   testAccessibleTree(acc, tree);
 
   let onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
     content.document.getElementById(contentId).removeChild(
-      content.document.getElementById('t6_span'));
+      content.document.getElementById("t6_span"));
   });
   await onReorder;
 
   tree = {
     SECTION: [
       { GROUPING: [ ] }
     ]
   };
   testAccessibleTree(acc, tree);
 }
 
-addAccessibleTask('doc_treeupdate_ariaowns.html', async function(browser, accDoc) {
+addAccessibleTask("doc_treeupdate_ariaowns.html", async function(browser, accDoc) {
   await testContainer1(browser, accDoc);
   await removeContainer(browser, accDoc);
   await stealAndRecacheChildren(browser, accDoc);
   await showHiddenElement(browser, accDoc);
   await rearrangeARIAOwns(browser, accDoc);
   await removeNotARIAOwnedEl(browser, accDoc);
 });
--- a/accessible/tests/browser/e10s/browser_treeupdate_canvas.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_canvas.js
@@ -1,24 +1,24 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 addAccessibleTask(`
   <canvas id="canvas">
     <div id="dialog" role="dialog" style="display: none;"></div>
   </canvas>`, async function(browser, accDoc) {
-  let canvas = findAccessibleChildByID(accDoc, 'canvas');
-  let dialog = findAccessibleChildByID(accDoc, 'dialog');
+  let canvas = findAccessibleChildByID(accDoc, "canvas");
+  let dialog = findAccessibleChildByID(accDoc, "dialog");
 
   testAccessibleTree(canvas, { CANVAS: [] });
 
-  let onShow = waitForEvent(EVENT_SHOW, 'dialog');
-  await invokeSetStyle(browser, 'dialog', 'display', 'block');
+  let onShow = waitForEvent(EVENT_SHOW, "dialog");
+  await invokeSetStyle(browser, "dialog", "display", "block");
   await onShow;
 
   testAccessibleTree(dialog, { DIALOG: [] });
 });
--- a/accessible/tests/browser/e10s/browser_treeupdate_cssoverflow.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_cssoverflow.js
@@ -1,42 +1,42 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 addAccessibleTask(`
   <div id="container"><div id="scrollarea" style="overflow:auto;"><input>
   </div></div>
   <div id="container2"><div id="scrollarea2" style="overflow:hidden;">
   </div></div>`, async function(browser, accDoc) {
-  const id1 = 'container';
-  const id2 = 'container2';
+  const id1 = "container";
+  const id2 = "container2";
   const container = findAccessibleChildByID(accDoc, id1);
   const container2 = findAccessibleChildByID(accDoc, id2);
 
   /* ================= Change scroll range ================================== */
   let tree = {
     SECTION: [ {// container
       SECTION: [ {// scroll area
         ENTRY: [ ] // child content
       } ]
     } ]
   };
   testAccessibleTree(container, tree);
 
   let onReorder = waitForEvent(EVENT_REORDER, id1);
   await ContentTask.spawn(browser, id1, id => {
     let doc = content.document;
-    doc.getElementById('scrollarea').style.width = '20px';
-    doc.getElementById(id).appendChild(doc.createElement('input'));
+    doc.getElementById("scrollarea").style.width = "20px";
+    doc.getElementById(id).appendChild(doc.createElement("input"));
   });
   await onReorder;
 
   tree = {
     SECTION: [ {// container
       SECTION: [ {// scroll area
         ENTRY: [ ] // child content
       } ]
@@ -46,17 +46,17 @@ addAccessibleTask(`
   };
   testAccessibleTree(container, tree);
 
   /* ================= Change scrollbar styles ============================== */
   tree = { SECTION: [ ] };
   testAccessibleTree(container2, tree);
 
   onReorder = waitForEvent(EVENT_REORDER, id2);
-  await invokeSetStyle(browser, 'scrollarea2', 'overflow', 'auto');
+  await invokeSetStyle(browser, "scrollarea2", "overflow", "auto");
   await onReorder;
 
   tree = {
     SECTION: [ // container
       { SECTION: [] } // scroll area
     ]
   };
   testAccessibleTree(container2, tree);
--- a/accessible/tests/browser/e10s/browser_treeupdate_doc.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_doc.js
@@ -1,121 +1,121 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 const iframeSrc = `data:text/html,
   <html>
     <head>
       <meta charset='utf-8'/>
       <title>Inner Iframe</title>
     </head>
     <body id='inner-iframe'></body>
   </html>`;
 
 addAccessibleTask(`
   <iframe id="iframe" src="${iframeSrc}"></iframe>`, async function(browser, accDoc) {
   // ID of the iframe that is being tested
-  const id = 'inner-iframe';
+  const id = "inner-iframe";
 
   let iframe = findAccessibleChildByID(accDoc, id);
 
   /* ================= Initial tree check =================================== */
   let tree = {
     role: ROLE_DOCUMENT,
     children: [ ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Write iframe document ================================ */
   let reorderEventPromise = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
-    let docNode = content.document.getElementById('iframe').contentDocument;
-    let newHTMLNode = docNode.createElement('html');
-    let newBodyNode = docNode.createElement('body');
-    let newTextNode = docNode.createTextNode('New Wave');
+    let docNode = content.document.getElementById("iframe").contentDocument;
+    let newHTMLNode = docNode.createElement("html");
+    let newBodyNode = docNode.createElement("body");
+    let newTextNode = docNode.createTextNode("New Wave");
     newBodyNode.id = contentId;
     newBodyNode.appendChild(newTextNode);
     newHTMLNode.appendChild(newBodyNode);
     docNode.replaceChild(newHTMLNode, docNode.documentElement);
   });
   await reorderEventPromise;
 
   tree = {
     role: ROLE_DOCUMENT,
     children: [
       {
         role: ROLE_TEXT_LEAF,
-        name: 'New Wave'
+        name: "New Wave"
       }
     ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Replace iframe HTML element ========================== */
   reorderEventPromise = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
-    let docNode = content.document.getElementById('iframe').contentDocument;
+    let docNode = content.document.getElementById("iframe").contentDocument;
     // We can't use open/write/close outside of iframe document because of
     // security error.
-    let script = docNode.createElement('script');
+    let script = docNode.createElement("script");
     script.textContent = `
       document.open();
       document.write('<body id="${contentId}">hello</body>');
       document.close();`;
     docNode.body.appendChild(script);
   });
   await reorderEventPromise;
 
   tree = {
     role: ROLE_DOCUMENT,
     children: [
       {
         role: ROLE_TEXT_LEAF,
-        name: 'hello'
+        name: "hello"
       }
     ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Replace iframe body ================================== */
   reorderEventPromise = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
-    let docNode = content.document.getElementById('iframe').contentDocument;
-    let newBodyNode = docNode.createElement('body');
-    let newTextNode = docNode.createTextNode('New Hello');
+    let docNode = content.document.getElementById("iframe").contentDocument;
+    let newBodyNode = docNode.createElement("body");
+    let newTextNode = docNode.createTextNode("New Hello");
     newBodyNode.id = contentId;
     newBodyNode.appendChild(newTextNode);
-    newBodyNode.setAttribute('role', 'button');
+    newBodyNode.setAttribute("role", "button");
     docNode.documentElement.replaceChild(newBodyNode, docNode.body);
   });
   await reorderEventPromise;
 
   tree = {
     role: ROLE_PUSHBUTTON,
     children: [
       {
         role: ROLE_TEXT_LEAF,
-        name: 'New Hello'
+        name: "New Hello"
       }
     ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Open iframe document ================================= */
   reorderEventPromise = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
     // Open document.
-    let docNode = content.document.getElementById('iframe').contentDocument;
-    let script = docNode.createElement('script');
+    let docNode = content.document.getElementById("iframe").contentDocument;
+    let script = docNode.createElement("script");
     script.textContent = `
       function closeMe() {
         document.write('Works?');
         document.close();
       }
       window.closeMe = closeMe;
       document.open();
       document.write('<body id="${contentId}"></body>');`;
@@ -128,183 +128,183 @@ addAccessibleTask(`
     children: [ ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Close iframe document ================================ */
   reorderEventPromise = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, {}, () => {
     // Write and close document.
-    let docNode = content.document.getElementById('iframe').contentDocument;
-    docNode.write('Works?');
+    let docNode = content.document.getElementById("iframe").contentDocument;
+    docNode.write("Works?");
     docNode.close();
   });
   await reorderEventPromise;
 
   tree = {
     role: ROLE_DOCUMENT,
     children: [
       {
         role: ROLE_TEXT_LEAF,
-        name: 'Works?'
+        name: "Works?"
       }
     ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Remove HTML from iframe document ===================== */
   reorderEventPromise = waitForEvent(EVENT_REORDER, iframe);
   await ContentTask.spawn(browser, {}, () => {
     // Remove HTML element.
-    let docNode = content.document.getElementById('iframe').contentDocument;
+    let docNode = content.document.getElementById("iframe").contentDocument;
     docNode.firstChild.remove();
   });
   let event = await reorderEventPromise;
 
   ok(event.accessible instanceof nsIAccessibleDocument,
-    'Reorder should happen on the document');
+    "Reorder should happen on the document");
   tree = {
     role: ROLE_DOCUMENT,
     children: [ ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Insert HTML to iframe document ======================= */
   reorderEventPromise = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
     // Insert HTML element.
-    let docNode = content.document.getElementById('iframe').contentDocument;
-    let html = docNode.createElement('html');
-    let body = docNode.createElement('body');
-    let text = docNode.createTextNode('Haha');
+    let docNode = content.document.getElementById("iframe").contentDocument;
+    let html = docNode.createElement("html");
+    let body = docNode.createElement("body");
+    let text = docNode.createTextNode("Haha");
     body.appendChild(text);
     body.id = contentId;
     html.appendChild(body);
     docNode.appendChild(html);
   });
   await reorderEventPromise;
 
   tree = {
     role: ROLE_DOCUMENT,
     children: [
       {
         role: ROLE_TEXT_LEAF,
-        name: 'Haha'
+        name: "Haha"
       }
     ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Remove body from iframe document ===================== */
   reorderEventPromise = waitForEvent(EVENT_REORDER, iframe);
   await ContentTask.spawn(browser, {}, () => {
     // Remove body element.
-    let docNode = content.document.getElementById('iframe').contentDocument;
+    let docNode = content.document.getElementById("iframe").contentDocument;
     docNode.documentElement.removeChild(docNode.body);
   });
   event = await reorderEventPromise;
 
   ok(event.accessible instanceof nsIAccessibleDocument,
-    'Reorder should happen on the document');
+    "Reorder should happen on the document");
   tree = {
     role: ROLE_DOCUMENT,
     children: [ ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================ Insert element under document element while body missed */
   reorderEventPromise = waitForEvent(EVENT_REORDER, iframe);
   await ContentTask.spawn(browser, {}, () => {
-    let docNode = content.document.getElementById('iframe').contentDocument;
-    let inputNode = content.window.inputNode = docNode.createElement('input');
+    let docNode = content.document.getElementById("iframe").contentDocument;
+    let inputNode = content.window.inputNode = docNode.createElement("input");
     docNode.documentElement.appendChild(inputNode);
   });
   event = await reorderEventPromise;
 
   ok(event.accessible instanceof nsIAccessibleDocument,
-    'Reorder should happen on the document');
+    "Reorder should happen on the document");
   tree = {
     DOCUMENT: [
       { ENTRY: [ ] }
     ]
   };
   testAccessibleTree(iframe, tree);
 
   reorderEventPromise = waitForEvent(EVENT_REORDER, iframe);
   await ContentTask.spawn(browser, {}, () => {
     let docEl =
-      content.document.getElementById('iframe').contentDocument.documentElement;
+      content.document.getElementById("iframe").contentDocument.documentElement;
     // Remove aftermath of this test before next test starts.
     docEl.firstChild.remove();
   });
   // Make sure reorder event was fired and that the input was removed.
   await reorderEventPromise;
   tree = {
     role: ROLE_DOCUMENT,
     children: [ ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Insert body to iframe document ======================= */
   reorderEventPromise = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
     // Write and close document.
-    let docNode = content.document.getElementById('iframe').contentDocument;
+    let docNode = content.document.getElementById("iframe").contentDocument;
     // Insert body element.
-    let body = docNode.createElement('body');
-    let text = docNode.createTextNode('Yo ho ho i butylka roma!');
+    let body = docNode.createElement("body");
+    let text = docNode.createTextNode("Yo ho ho i butylka roma!");
     body.appendChild(text);
     body.id = contentId;
     docNode.documentElement.appendChild(body);
   });
   await reorderEventPromise;
 
   tree = {
     role: ROLE_DOCUMENT,
     children: [
       {
         role: ROLE_TEXT_LEAF,
-        name: 'Yo ho ho i butylka roma!'
+        name: "Yo ho ho i butylka roma!"
       }
     ]
   };
   testAccessibleTree(iframe, tree);
 
   /* ================= Change source ======================================== */
-  reorderEventPromise = waitForEvent(EVENT_REORDER, 'iframe');
-  await invokeSetAttribute(browser, 'iframe', 'src',
+  reorderEventPromise = waitForEvent(EVENT_REORDER, "iframe");
+  await invokeSetAttribute(browser, "iframe", "src",
     `data:text/html,<html><body id="${id}"><input></body></html>`);
   event = await reorderEventPromise;
 
   tree = {
     INTERNAL_FRAME: [
       { DOCUMENT: [
         { ENTRY: [ ] }
       ] }
     ]
   };
   testAccessibleTree(event.accessible, tree);
   iframe = findAccessibleChildByID(event.accessible, id);
 
   /* ================= Replace iframe body on ARIA role body ================ */
   reorderEventPromise = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
-    let docNode = content.document.getElementById('iframe').contentDocument;
-    let newBodyNode = docNode.createElement('body');
-    let newTextNode = docNode.createTextNode('New Hello');
+    let docNode = content.document.getElementById("iframe").contentDocument;
+    let newBodyNode = docNode.createElement("body");
+    let newTextNode = docNode.createTextNode("New Hello");
     newBodyNode.appendChild(newTextNode);
-    newBodyNode.setAttribute('role', 'button');
+    newBodyNode.setAttribute("role", "button");
     newBodyNode.id = contentId;
     docNode.documentElement.replaceChild(newBodyNode, docNode.body);
   });
   await reorderEventPromise;
 
   tree = {
     role: ROLE_PUSHBUTTON,
     children: [
       {
         role: ROLE_TEXT_LEAF,
-        name: 'New Hello'
+        name: "New Hello"
       }
     ]
   };
   testAccessibleTree(iframe, tree);
 });
--- a/accessible/tests/browser/e10s/browser_treeupdate_gencontent.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_gencontent.js
@@ -1,31 +1,31 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 addAccessibleTask(`
   <style>
     .gentext:before {
       content: "START"
     }
     .gentext:after {
       content: "END"
     }
   </style>
   <div id="container1"></div>
   <div id="container2"><div id="container2_child">text</div></div>`,
   async function(browser, accDoc) {
-    const id1 = 'container1';
-    const id2 = 'container2';
+    const id1 = "container1";
+    const id2 = "container2";
     let container1 = findAccessibleChildByID(accDoc, id1);
     let container2 = findAccessibleChildByID(accDoc, id2);
 
     let tree = {
       SECTION: [ ] // container
     };
     testAccessibleTree(container1, tree);
 
@@ -36,19 +36,19 @@ addAccessibleTask(`
         } ]
       } ]
     };
     testAccessibleTree(container2, tree);
 
     let onReorder = waitForEvent(EVENT_REORDER, id1);
     // Create and add an element with CSS generated content to container1
     await ContentTask.spawn(browser, id1, id => {
-      let node = content.document.createElement('div');
-      node.textContent = 'text';
-      node.setAttribute('class', 'gentext');
+      let node = content.document.createElement("div");
+      node.textContent = "text";
+      node.setAttribute("class", "gentext");
       content.document.getElementById(id).appendChild(node);
     });
     await onReorder;
 
     tree = {
       SECTION: [ // container
         { SECTION: [ // inserted node
           { STATICTEXT: [] }, // :before
@@ -56,17 +56,17 @@ addAccessibleTask(`
           { STATICTEXT: [] } // :after
         ] }
       ]
     };
     testAccessibleTree(container1, tree);
 
     onReorder = waitForEvent(EVENT_REORDER, id2);
     // Add CSS generated content to an element in container2's subtree
-    await invokeSetAttribute(browser, 'container2_child', 'class', 'gentext');
+    await invokeSetAttribute(browser, "container2_child", "class", "gentext");
     await onReorder;
 
     tree = {
       SECTION: [ // container2
         { SECTION: [ // container2 child
           { STATICTEXT: [] }, // :before
           { TEXT_LEAF: [] }, // primary text
           { STATICTEXT: [] } // :after
--- a/accessible/tests/browser/e10s/browser_treeupdate_hidden.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_hidden.js
@@ -1,29 +1,29 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 async function setHidden(browser, value) {
-  let onReorder = waitForEvent(EVENT_REORDER, 'container');
-  await invokeSetAttribute(browser, 'child', 'hidden', value);
+  let onReorder = waitForEvent(EVENT_REORDER, "container");
+  await invokeSetAttribute(browser, "child", "hidden", value);
   await onReorder;
 }
 
 addAccessibleTask('<div id="container"><input id="child"></div>',
   async function(browser, accDoc) {
-    let container = findAccessibleChildByID(accDoc, 'container');
+    let container = findAccessibleChildByID(accDoc, "container");
 
     testAccessibleTree(container, { SECTION: [ { ENTRY: [ ] } ] });
 
     // Set @hidden attribute
-    await setHidden(browser, 'true');
+    await setHidden(browser, "true");
     testAccessibleTree(container, { SECTION: [ ] });
 
     // Remove @hidden attribute
     await setHidden(browser);
     testAccessibleTree(container, { SECTION: [ { ENTRY: [ ] } ] });
   });
--- a/accessible/tests/browser/e10s/browser_treeupdate_imagemap.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_imagemap.js
@@ -1,153 +1,153 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 async function testImageMap(browser, accDoc) {
-  const id = 'imgmap';
+  const id = "imgmap";
   const acc = findAccessibleChildByID(accDoc, id);
 
   /* ================= Initial tree test ==================================== */
   let tree = {
     IMAGE_MAP: [
-      { role: ROLE_LINK, name: 'b', children: [ ] }
+      { role: ROLE_LINK, name: "b", children: [ ] }
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================= Insert area ========================================== */
   let onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, {}, () => {
-    let areaElm = content.document.createElement('area');
-    let mapNode = content.document.getElementById('map');
-    areaElm.setAttribute('href',
-                         'http://www.bbc.co.uk/radio4/atoz/index.shtml#a');
-    areaElm.setAttribute('coords', '0,0,13,14');
-    areaElm.setAttribute('alt', 'a');
-    areaElm.setAttribute('shape', 'rect');
+    let areaElm = content.document.createElement("area");
+    let mapNode = content.document.getElementById("map");
+    areaElm.setAttribute("href",
+                         "http://www.bbc.co.uk/radio4/atoz/index.shtml#a");
+    areaElm.setAttribute("coords", "0,0,13,14");
+    areaElm.setAttribute("alt", "a");
+    areaElm.setAttribute("shape", "rect");
     mapNode.insertBefore(areaElm, mapNode.firstChild);
   });
   await onReorder;
 
   tree = {
     IMAGE_MAP: [
-      { role: ROLE_LINK, name: 'a', children: [ ] },
-      { role: ROLE_LINK, name: 'b', children: [ ] }
+      { role: ROLE_LINK, name: "a", children: [ ] },
+      { role: ROLE_LINK, name: "b", children: [ ] }
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================= Append area ========================================== */
   onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, {}, () => {
-    let areaElm = content.document.createElement('area');
-    let mapNode = content.document.getElementById('map');
-    areaElm.setAttribute('href',
-                         'http://www.bbc.co.uk/radio4/atoz/index.shtml#c');
-    areaElm.setAttribute('coords', '34,0,47,14');
-    areaElm.setAttribute('alt', 'c');
-    areaElm.setAttribute('shape', 'rect');
+    let areaElm = content.document.createElement("area");
+    let mapNode = content.document.getElementById("map");
+    areaElm.setAttribute("href",
+                         "http://www.bbc.co.uk/radio4/atoz/index.shtml#c");
+    areaElm.setAttribute("coords", "34,0,47,14");
+    areaElm.setAttribute("alt", "c");
+    areaElm.setAttribute("shape", "rect");
     mapNode.appendChild(areaElm);
   });
   await onReorder;
 
   tree = {
     IMAGE_MAP: [
-      { role: ROLE_LINK, name: 'a', children: [ ] },
-      { role: ROLE_LINK, name: 'b', children: [ ] },
-      { role: ROLE_LINK, name: 'c', children: [ ] }
+      { role: ROLE_LINK, name: "a", children: [ ] },
+      { role: ROLE_LINK, name: "b", children: [ ] },
+      { role: ROLE_LINK, name: "c", children: [ ] }
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================= Remove area ========================================== */
   onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, {}, () => {
-    let mapNode = content.document.getElementById('map');
+    let mapNode = content.document.getElementById("map");
     mapNode.removeChild(mapNode.firstElementChild);
   });
   await onReorder;
 
   tree = {
     IMAGE_MAP: [
-      { role: ROLE_LINK, name: 'b', children: [ ] },
-      { role: ROLE_LINK, name: 'c', children: [ ] }
+      { role: ROLE_LINK, name: "b", children: [ ] },
+      { role: ROLE_LINK, name: "c", children: [ ] }
     ]
   };
   testAccessibleTree(acc, tree);
 }
 
 async function testContainer(browser) {
-  const id = 'container';
+  const id = "container";
   /* ================= Remove name on map =================================== */
   let onReorder = waitForEvent(EVENT_REORDER, id);
-  await invokeSetAttribute(browser, 'map', 'name');
+  await invokeSetAttribute(browser, "map", "name");
   let event = await onReorder;
   const acc = event.accessible;
 
   let tree = {
     SECTION: [
       { GRAPHIC: [ ] }
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================= Restore name on map ================================== */
   onReorder = waitForEvent(EVENT_REORDER, id);
-  await invokeSetAttribute(browser, 'map', 'name', 'atoz_map');
+  await invokeSetAttribute(browser, "map", "name", "atoz_map");
   // XXX: force repainting of the image (see bug 745788 for details).
-  await BrowserTestUtils.synthesizeMouse('#imgmap', 10, 10,
-    { type: 'mousemove' }, browser);
+  await BrowserTestUtils.synthesizeMouse("#imgmap", 10, 10,
+    { type: "mousemove" }, browser);
   await onReorder;
 
   tree = {
     SECTION: [ {
       IMAGE_MAP: [
         { LINK: [ ] },
         { LINK: [ ] }
       ]
     } ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================= Remove map =========================================== */
   onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, {}, () => {
-    let mapNode = content.document.getElementById('map');
+    let mapNode = content.document.getElementById("map");
     mapNode.remove();
   });
   await onReorder;
 
   tree = {
     SECTION: [
       { GRAPHIC: [ ] }
     ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================= Insert map =========================================== */
   onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
-    let map = content.document.createElement('map');
-    let area = content.document.createElement('area');
+    let map = content.document.createElement("map");
+    let area = content.document.createElement("area");
 
-    map.setAttribute('name', 'atoz_map');
-    map.setAttribute('id', 'map');
+    map.setAttribute("name", "atoz_map");
+    map.setAttribute("id", "map");
 
-    area.setAttribute('href',
-                      'http://www.bbc.co.uk/radio4/atoz/index.shtml#b');
-    area.setAttribute('coords', '17,0,30,14');
-    area.setAttribute('alt', 'b');
-    area.setAttribute('shape', 'rect');
+    area.setAttribute("href",
+                      "http://www.bbc.co.uk/radio4/atoz/index.shtml#b");
+    area.setAttribute("coords", "17,0,30,14");
+    area.setAttribute("alt", "b");
+    area.setAttribute("shape", "rect");
 
     map.appendChild(area);
     content.document.getElementById(contentId).appendChild(map);
   });
   await onReorder;
 
   tree = {
     SECTION: [ {
@@ -155,36 +155,36 @@ async function testContainer(browser) {
         { LINK: [ ] }
       ]
     } ]
   };
   testAccessibleTree(acc, tree);
 
   /* ================= Hide image map ======================================= */
   onReorder = waitForEvent(EVENT_REORDER, id);
-  await invokeSetStyle(browser, 'imgmap', 'display', 'none');
+  await invokeSetStyle(browser, "imgmap", "display", "none");
   await onReorder;
 
   tree = {
     SECTION: [ ]
   };
   testAccessibleTree(acc, tree);
 }
 
 async function waitForImageMap(browser, accDoc) {
-  const id = 'imgmap';
+  const id = "imgmap";
   const acc = findAccessibleChildByID(accDoc, id);
   if (acc.firstChild) {
     return;
   }
 
   const onReorder = waitForEvent(EVENT_REORDER, id);
   // Wave over image map
   await BrowserTestUtils.synthesizeMouse(`#${id}`, 10, 10,
-                                         { type: 'mousemove' }, browser);
+                                         { type: "mousemove" }, browser);
   await onReorder;
 }
 
-addAccessibleTask('doc_treeupdate_imagemap.html', async function(browser, accDoc) {
+addAccessibleTask("doc_treeupdate_imagemap.html", async function(browser, accDoc) {
   await waitForImageMap(browser, accDoc);
   await testImageMap(browser, accDoc);
   await testContainer(browser);
 });
--- a/accessible/tests/browser/e10s/browser_treeupdate_list.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_list.js
@@ -1,42 +1,42 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 async function setDisplayAndWaitForReorder(browser, value) {
-  let onReorder = waitForEvent(EVENT_REORDER, 'ul');
-  await invokeSetStyle(browser, 'li', 'display', value);
+  let onReorder = waitForEvent(EVENT_REORDER, "ul");
+  await invokeSetStyle(browser, "li", "display", value);
   return onReorder;
 }
 
 addAccessibleTask(`
   <ul id="ul">
     <li id="li">item1</li>
   </ul>`, async function(browser, accDoc) {
-  let li = findAccessibleChildByID(accDoc, 'li');
+  let li = findAccessibleChildByID(accDoc, "li");
   let bullet = li.firstChild;
   let accTree = {
     role: ROLE_LISTITEM,
     children: [ {
       role: ROLE_STATICTEXT,
       children: []
     }, {
       role: ROLE_TEXT_LEAF,
       children: []
     } ]
   };
   testAccessibleTree(li, accTree);
 
-  await setDisplayAndWaitForReorder(browser, 'none');
+  await setDisplayAndWaitForReorder(browser, "none");
 
-  ok(isDefunct(li), 'Check that li is defunct.');
-  ok(isDefunct(bullet), 'Check that bullet is defunct.');
+  ok(isDefunct(li), "Check that li is defunct.");
+  ok(isDefunct(bullet), "Check that bullet is defunct.");
 
-  let event = await setDisplayAndWaitForReorder(browser, 'list-item');
+  let event = await setDisplayAndWaitForReorder(browser, "list-item");
 
-  testAccessibleTree(findAccessibleChildByID(event.accessible, 'li'), accTree);
+  testAccessibleTree(findAccessibleChildByID(event.accessible, "li"), accTree);
 });
--- a/accessible/tests/browser/e10s/browser_treeupdate_list_editabledoc.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_list_editabledoc.js
@@ -1,31 +1,31 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 addAccessibleTask('<ol id="list"></ol>', async function(browser, accDoc) {
-  let list = findAccessibleChildByID(accDoc, 'list');
+  let list = findAccessibleChildByID(accDoc, "list");
 
   testAccessibleTree(list, {
     role: ROLE_LIST,
     children: [ ]
   });
 
-  await invokeSetAttribute(browser, 'body', 'contentEditable', 'true');
-  let onReorder = waitForEvent(EVENT_REORDER, 'list');
+  await invokeSetAttribute(browser, "body", "contentEditable", "true");
+  let onReorder = waitForEvent(EVENT_REORDER, "list");
   await ContentTask.spawn(browser, {}, () => {
-    let li = content.document.createElement('li');
-    li.textContent = 'item';
-    content.document.getElementById('list').appendChild(li);
+    let li = content.document.createElement("li");
+    li.textContent = "item";
+    content.document.getElementById("list").appendChild(li);
   });
   await onReorder;
 
   testAccessibleTree(list, {
     role: ROLE_LIST,
     children: [ {
       role: ROLE_LISTITEM,
       children: [
--- a/accessible/tests/browser/e10s/browser_treeupdate_listener.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_listener.js
@@ -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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 addAccessibleTask('<span id="parent"><span id="child"></span></span>',
   async function(browser, accDoc) {
-    is(findAccessibleChildByID(accDoc, 'parent'), null,
-      'Check that parent is not accessible.');
-    is(findAccessibleChildByID(accDoc, 'child'), null,
-      'Check that child is not accessible.');
+    is(findAccessibleChildByID(accDoc, "parent"), null,
+      "Check that parent is not accessible.");
+    is(findAccessibleChildByID(accDoc, "child"), null,
+      "Check that child is not accessible.");
 
-    let onReorder = waitForEvent(EVENT_REORDER, 'body');
+    let onReorder = waitForEvent(EVENT_REORDER, "body");
     // Add an event listener to parent.
     await ContentTask.spawn(browser, {}, () => {
       content.window.dummyListener = () => {};
-      content.document.getElementById('parent').addEventListener(
-        'click', content.window.dummyListener);
+      content.document.getElementById("parent").addEventListener(
+        "click", content.window.dummyListener);
     });
     await onReorder;
 
     let tree = { TEXT: [] };
-    testAccessibleTree(findAccessibleChildByID(accDoc, 'parent'), tree);
+    testAccessibleTree(findAccessibleChildByID(accDoc, "parent"), tree);
   });
--- a/accessible/tests/browser/e10s/browser_treeupdate_optgroup.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_optgroup.js
@@ -1,85 +1,85 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 addAccessibleTask('<select id="select"></select>', async function(browser, accDoc) {
-  let select = findAccessibleChildByID(accDoc, 'select');
+  let select = findAccessibleChildByID(accDoc, "select");
 
-  let onEvent = waitForEvent(EVENT_REORDER, 'select');
+  let onEvent = waitForEvent(EVENT_REORDER, "select");
   // Create a combobox with grouping and 2 standalone options
   await ContentTask.spawn(browser, {}, () => {
     let doc = content.document;
-    let contentSelect = doc.getElementById('select');
-    let optGroup = doc.createElement('optgroup');
+    let contentSelect = doc.getElementById("select");
+    let optGroup = doc.createElement("optgroup");
 
     for (let i = 0; i < 2; i++) {
-      let opt = doc.createElement('option');
+      let opt = doc.createElement("option");
       opt.value = i;
-      opt.text = 'Option: Value ' + i;
+      opt.text = "Option: Value " + i;
       optGroup.appendChild(opt);
     }
     contentSelect.add(optGroup, null);
 
     for (let i = 0; i < 2; i++) {
-      let opt = doc.createElement('option');
+      let opt = doc.createElement("option");
       contentSelect.add(opt, null);
     }
-    contentSelect.firstChild.firstChild.id = 'option1Node';
+    contentSelect.firstChild.firstChild.id = "option1Node";
   });
   let event = await onEvent;
-  let option1Node = findAccessibleChildByID(event.accessible, 'option1Node');
+  let option1Node = findAccessibleChildByID(event.accessible, "option1Node");
 
   let tree = {
     COMBOBOX: [ {
       COMBOBOX_LIST: [ {
         GROUPING: [
           { COMBOBOX_OPTION: [ { TEXT_LEAF: [] } ] },
           { COMBOBOX_OPTION: [ { TEXT_LEAF: [] } ] }
         ]
       }, {
         COMBOBOX_OPTION: []
       }, {
         COMBOBOX_OPTION: []
       } ]
     } ]
   };
   testAccessibleTree(select, tree);
-  ok(!isDefunct(option1Node), 'option shouldn\'t be defunct');
+  ok(!isDefunct(option1Node), "option shouldn't be defunct");
 
-  onEvent = waitForEvent(EVENT_REORDER, 'select');
+  onEvent = waitForEvent(EVENT_REORDER, "select");
   // Remove grouping from combobox
   await ContentTask.spawn(browser, {}, () => {
-    let contentSelect = content.document.getElementById('select');
+    let contentSelect = content.document.getElementById("select");
     contentSelect.firstChild.remove();
   });
   await onEvent;
 
   tree = {
     COMBOBOX: [ {
       COMBOBOX_LIST: [
         { COMBOBOX_OPTION: [] },
         { COMBOBOX_OPTION: [] }
       ]
     } ]
   };
   testAccessibleTree(select, tree);
   ok(isDefunct(option1Node),
-    'removed option shouldn\'t be accessible anymore!');
+    "removed option shouldn't be accessible anymore!");
 
-  onEvent = waitForEvent(EVENT_REORDER, 'select');
+  onEvent = waitForEvent(EVENT_REORDER, "select");
   // Remove all options from combobox
   await ContentTask.spawn(browser, {}, () => {
-    let contentSelect = content.document.getElementById('select');
+    let contentSelect = content.document.getElementById("select");
     while (contentSelect.length) {
       contentSelect.remove(0);
     }
   });
   await onEvent;
 
   tree = {
     COMBOBOX: [ {
--- a/accessible/tests/browser/e10s/browser_treeupdate_removal.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_removal.js
@@ -1,38 +1,38 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
-addAccessibleTask('doc_treeupdate_removal.xhtml', async function(browser, accDoc) {
-  ok(isAccessible(findAccessibleChildByID(accDoc, 'the_table')),
-    'table should be accessible');
+addAccessibleTask("doc_treeupdate_removal.xhtml", async function(browser, accDoc) {
+  ok(isAccessible(findAccessibleChildByID(accDoc, "the_table")),
+    "table should be accessible");
 
   // Move the_table element into hidden subtree.
-  let onReorder = waitForEvent(EVENT_REORDER, 'body');
+  let onReorder = waitForEvent(EVENT_REORDER, "body");
   await ContentTask.spawn(browser, {}, () => content.document.getElementById(
-    'the_displaynone').appendChild(content.document.getElementById(
-      'the_table')));
+    "the_displaynone").appendChild(content.document.getElementById(
+      "the_table")));
   await onReorder;
 
-  ok(!isAccessible(findAccessibleChildByID(accDoc, 'the_table')),
-    'table in display none tree shouldn\'t be accessible');
-  ok(!isAccessible(findAccessibleChildByID(accDoc, 'the_row')),
-    'row shouldn\'t be accessible');
+  ok(!isAccessible(findAccessibleChildByID(accDoc, "the_table")),
+    "table in display none tree shouldn't be accessible");
+  ok(!isAccessible(findAccessibleChildByID(accDoc, "the_row")),
+    "row shouldn't be accessible");
 
   // Remove the_row element (since it did not have accessible, no event needed).
   await ContentTask.spawn(browser, {}, () =>
     content.document.body.removeChild(
-      content.document.getElementById('the_row')));
+      content.document.getElementById("the_row")));
 
   // make sure no accessibles have stuck around.
-  ok(!isAccessible(findAccessibleChildByID(accDoc, 'the_row')),
-    'row shouldn\'t be accessible');
-  ok(!isAccessible(findAccessibleChildByID(accDoc, 'the_table')),
-    'table shouldn\'t be accessible');
-  ok(!isAccessible(findAccessibleChildByID(accDoc, 'the_displayNone')),
-    'display none things shouldn\'t be accessible');
+  ok(!isAccessible(findAccessibleChildByID(accDoc, "the_row")),
+    "row shouldn't be accessible");
+  ok(!isAccessible(findAccessibleChildByID(accDoc, "the_table")),
+    "table shouldn't be accessible");
+  ok(!isAccessible(findAccessibleChildByID(accDoc, "the_displayNone")),
+    "display none things shouldn't be accessible");
 });
--- a/accessible/tests/browser/e10s/browser_treeupdate_table.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_table.js
@@ -1,44 +1,44 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 addAccessibleTask(`
   <table id="table">
     <tr>
       <td>cell1</td>
       <td>cell2</td>
     </tr>
   </table>`, async function(browser, accDoc) {
-  let table = findAccessibleChildByID(accDoc, 'table');
+  let table = findAccessibleChildByID(accDoc, "table");
 
   let tree = {
     TABLE: [
       { ROW: [
         { CELL: [ {TEXT_LEAF: [] }]},
         { CELL: [ {TEXT_LEAF: [] }]}
       ] }
     ]
   };
   testAccessibleTree(table, tree);
 
-  let onReorder = waitForEvent(EVENT_REORDER, 'table');
+  let onReorder = waitForEvent(EVENT_REORDER, "table");
   await ContentTask.spawn(browser, {}, () => {
     // append a caption, it should appear as a first element in the
     // accessible tree.
     let doc = content.document;
-    let caption = doc.createElement('caption');
-    caption.textContent = 'table caption';
-    doc.getElementById('table').appendChild(caption);
+    let caption = doc.createElement("caption");
+    caption.textContent = "table caption";
+    doc.getElementById("table").appendChild(caption);
   });
   await onReorder;
 
   tree = {
     TABLE: [
       { CAPTION: [ { TEXT_LEAF: [] } ] },
       { ROW: [
         { CELL: [ {TEXT_LEAF: [] }]},
--- a/accessible/tests/browser/e10s/browser_treeupdate_textleaf.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_textleaf.js
@@ -1,34 +1,34 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 async function removeTextData(browser, accessible, id, role) {
   let tree = {
     role: role,
     children: [ { role: ROLE_TEXT_LEAF, name: "text" } ]
   };
   testAccessibleTree(accessible, tree);
 
   let onReorder = waitForEvent(EVENT_REORDER, id);
   await ContentTask.spawn(browser, id, contentId => {
-    content.document.getElementById(contentId).firstChild.textContent = '';
+    content.document.getElementById(contentId).firstChild.textContent = "";
   });
   await onReorder;
 
   tree = { role: role, children: [] };
   testAccessibleTree(accessible, tree);
 }
 
 addAccessibleTask(`
   <p id="p">text</p>
   <pre id="pre">text</pre>`, async function(browser, accDoc) {
-  let p = findAccessibleChildByID(accDoc, 'p');
-  let pre = findAccessibleChildByID(accDoc, 'pre');
-  await removeTextData(browser, p, 'p', ROLE_PARAGRAPH);
-  await removeTextData(browser, pre, 'pre', ROLE_TEXT_CONTAINER);
+  let p = findAccessibleChildByID(accDoc, "p");
+  let pre = findAccessibleChildByID(accDoc, "pre");
+  await removeTextData(browser, p, "p", ROLE_PARAGRAPH);
+  await removeTextData(browser, pre, "pre", ROLE_TEXT_CONTAINER);
 });
--- a/accessible/tests/browser/e10s/browser_treeupdate_visibility.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_visibility.js
@@ -1,23 +1,23 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
 async function testTreeOnHide(browser, accDoc, containerID, id, before, after) {
   let acc = findAccessibleChildByID(accDoc, containerID);
   testAccessibleTree(acc, before);
 
   let onReorder = waitForEvent(EVENT_REORDER, containerID);
-  await invokeSetStyle(browser, id, 'visibility', 'hidden');
+  await invokeSetStyle(browser, id, "visibility", "hidden");
   await onReorder;
 
   testAccessibleTree(acc, after);
 }
 
 async function test3(browser, accessible) {
   let tree = {
     SECTION: [ // container
@@ -29,22 +29,22 @@ async function test3(browser, accessible
       { SECTION: [ // parent2
         { SECTION: [ // child2
           { TEXT_LEAF: [] }
         ] }
       ] }
     ] };
   testAccessibleTree(accessible, tree);
 
-  let onReorder = waitForEvent(EVENT_REORDER, 't3_container');
+  let onReorder = waitForEvent(EVENT_REORDER, "t3_container");
   await ContentTask.spawn(browser, {}, () => {
     let doc = content.document;
-    doc.getElementById('t3_container').style.color = 'red';
-    doc.getElementById('t3_parent').style.visibility = 'hidden';
-    doc.getElementById('t3_parent2').style.visibility = 'hidden';
+    doc.getElementById("t3_container").style.color = "red";
+    doc.getElementById("t3_parent").style.visibility = "hidden";
+    doc.getElementById("t3_parent2").style.visibility = "hidden";
   });
   await onReorder;
 
   tree = {
     SECTION: [ // container
       { SECTION: [ // child
         { TEXT_LEAF: [] }
       ] },
@@ -61,21 +61,21 @@ async function test4(browser, accessible
       { TABLE: [
         { ROW: [
           { CELL: [ ] }
         ] }
       ] }
     ] };
   testAccessibleTree(accessible, tree);
 
-  let onReorder = waitForEvent(EVENT_REORDER, 't4_parent');
+  let onReorder = waitForEvent(EVENT_REORDER, "t4_parent");
   await ContentTask.spawn(browser, {}, () => {
     let doc = content.document;
-    doc.getElementById('t4_container').style.color = 'red';
-    doc.getElementById('t4_child').style.visibility = 'visible';
+    doc.getElementById("t4_container").style.color = "red";
+    doc.getElementById("t4_child").style.visibility = "visible";
   });
   await onReorder;
 
   tree = {
     SECTION: [{
       TABLE: [{
         ROW: [{
           CELL: [{
@@ -85,33 +85,33 @@ async function test4(browser, accessible
           }]
         }]
       }]
     }]
   };
   testAccessibleTree(accessible, tree);
 }
 
-addAccessibleTask('doc_treeupdate_visibility.html', async function(browser, accDoc) {
-  let t3Container = findAccessibleChildByID(accDoc, 't3_container');
-  let t4Container = findAccessibleChildByID(accDoc, 't4_container');
+addAccessibleTask("doc_treeupdate_visibility.html", async function(browser, accDoc) {
+  let t3Container = findAccessibleChildByID(accDoc, "t3_container");
+  let t4Container = findAccessibleChildByID(accDoc, "t4_container");
 
-  await testTreeOnHide(browser, accDoc, 't1_container', 't1_parent', {
+  await testTreeOnHide(browser, accDoc, "t1_container", "t1_parent", {
     SECTION: [{
       SECTION: [{
         SECTION: [ { TEXT_LEAF: [] } ]
       }]
     }]
   }, {
     SECTION: [ {
       SECTION: [ { TEXT_LEAF: [] } ]
     } ]
   });
 
-  await testTreeOnHide(browser, accDoc, 't2_container', 't2_grandparent', {
+  await testTreeOnHide(browser, accDoc, "t2_container", "t2_grandparent", {
     SECTION: [{ // container
       SECTION: [{ // grand parent
         SECTION: [{
           SECTION: [{ // child
             TEXT_LEAF: []
           }]
         }, {
           SECTION: [{ // child2
@@ -130,17 +130,17 @@ addAccessibleTask('doc_treeupdate_visibi
         TEXT_LEAF: []
       }]
     }]
   });
 
   await test3(browser, t3Container);
   await test4(browser, t4Container);
 
-  await testTreeOnHide(browser, accDoc, 't5_container', 't5_subcontainer', {
+  await testTreeOnHide(browser, accDoc, "t5_container", "t5_subcontainer", {
     SECTION: [{ // container
       SECTION: [{ // subcontainer
         TABLE: [{
           ROW: [{
             CELL: [{
               SECTION: [{ // child
                 TEXT_LEAF: []
               }]
@@ -152,17 +152,17 @@ addAccessibleTask('doc_treeupdate_visibi
   }, {
     SECTION: [{ // container
       SECTION: [{ // child
         TEXT_LEAF: []
       }]
     }]
   });
 
-  await testTreeOnHide(browser, accDoc, 't6_container', 't6_subcontainer', {
+  await testTreeOnHide(browser, accDoc, "t6_container", "t6_subcontainer", {
     SECTION: [{ // container
       SECTION: [{ // subcontainer
         TABLE: [{
           ROW: [{
             CELL: [{
               TABLE: [{ // nested table
                 ROW: [{
                   CELL: [{
--- a/accessible/tests/browser/e10s/browser_treeupdate_whitespace.js
+++ b/accessible/tests/browser/e10s/browser_treeupdate_whitespace.js
@@ -1,38 +1,38 @@
 /* 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';
+"use strict";
 
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "role.js", dir: MOCHITESTS_DIR });
 
-addAccessibleTask('doc_treeupdate_whitespace.html', async function(browser, accDoc) {
-  let container1 = findAccessibleChildByID(accDoc, 'container1');
-  let container2Parent = findAccessibleChildByID(accDoc, 'container2-parent');
+addAccessibleTask("doc_treeupdate_whitespace.html", async function(browser, accDoc) {
+  let container1 = findAccessibleChildByID(accDoc, "container1");
+  let container2Parent = findAccessibleChildByID(accDoc, "container2-parent");
 
   let tree = {
     SECTION: [
       { GRAPHIC: [] },
       { TEXT_LEAF: [] },
       { GRAPHIC: [] },
       { TEXT_LEAF: [] },
       { GRAPHIC: [] }
     ]
   };
   testAccessibleTree(container1, tree);
 
-  let onReorder = waitForEvent(EVENT_REORDER, 'container1');
+  let onReorder = waitForEvent(EVENT_REORDER, "container1");
   // Remove img1 from container1
   await ContentTask.spawn(browser, {}, () => {
     let doc = content.document;
-    doc.getElementById('container1').removeChild(
-      doc.getElementById('img1'));
+    doc.getElementById("container1").removeChild(
+      doc.getElementById("img1"));
   });
   await onReorder;
 
   tree = {
     SECTION: [
       { GRAPHIC: [] },
       { TEXT_LEAF: [] },
       { GRAPHIC: [] }
@@ -43,24 +43,24 @@ addAccessibleTask('doc_treeupdate_whites
   tree = {
     SECTION: [
       { LINK: [] },
       { LINK: [ { GRAPHIC: [] } ] }
     ]
   };
   testAccessibleTree(container2Parent, tree);
 
-  onReorder = waitForEvent(EVENT_REORDER, 'container2-parent');
+  onReorder = waitForEvent(EVENT_REORDER, "container2-parent");
   // Append an img with valid src to container2
   await ContentTask.spawn(browser, {}, () => {
     let doc = content.document;
-    let img = doc.createElement('img');
-    img.setAttribute('src',
-      'http://example.com/a11y/accessible/tests/mochitest/moz.png');
-    doc.getElementById('container2').appendChild(img);
+    let img = doc.createElement("img");
+    img.setAttribute("src",
+      "http://example.com/a11y/accessible/tests/mochitest/moz.png");
+    doc.getElementById("container2").appendChild(img);
   });
   await onReorder;
 
   tree = {
     SECTION: [
       { LINK: [ { GRAPHIC: [ ] } ] },
       { TEXT_LEAF: [ ] },
       { LINK: [ { GRAPHIC: [ ] } ] }
--- a/accessible/tests/browser/e10s/head.js
+++ b/accessible/tests/browser/e10s/head.js
@@ -1,15 +1,15 @@
 /* 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';
+"use strict";
 
 // Load the shared-head file first.
 /* import-globals-from ../shared-head.js */
 Services.scriptloader.loadSubScript(
-  'chrome://mochitests/content/browser/accessible/tests/browser/shared-head.js',
+  "chrome://mochitests/content/browser/accessible/tests/browser/shared-head.js",
   this);
 
 // Loading and common.js from accessible/tests/mochitest/ for all tests, as
 // well as events.js.
-loadScripts({ name: 'common.js', dir: MOCHITESTS_DIR }, 'events.js');
+loadScripts({ name: "common.js", dir: MOCHITESTS_DIR }, "events.js");
--- a/accessible/tests/browser/events.js
+++ b/accessible/tests/browser/events.js
@@ -1,13 +1,13 @@
 /* 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';
+"use strict";
 
 // This is loaded by head.js, so has the same globals, hence we import the
 // globals from there.
 /* import-globals-from shared-head.js */
 /* import-globals-from ../mochitest/common.js */
 
 /* exported EVENT_REORDER, EVENT_SHOW, EVENT_TEXT_INSERTED, EVENT_TEXT_REMOVED,
             EVENT_DOCUMENT_LOAD_COMPLETE, EVENT_HIDE, EVENT_TEXT_CARET_MOVED,
@@ -39,17 +39,17 @@ function eventToString(event) {
   let type = eventTypeToString(event.eventType);
   let info = `Event type: ${type}`;
 
   if (event instanceof nsIAccessibleStateChangeEvent) {
     let stateStr = statesToString(event.isExtraState ? 0 : event.state,
                                   event.isExtraState ? event.state : 0);
     info += `, state: ${stateStr}, is enabled: ${event.isEnabled}`;
   } else if (event instanceof nsIAccessibleTextChangeEvent) {
-    let tcType = event.isInserted ? 'inserted' : 'removed';
+    let tcType = event.isInserted ? "inserted" : "removed";
     info += `, start: ${event.start}, length: ${event.length}, ${tcType} text: ${event.modifiedText}`;
   }
 
   info += `. Target: ${prettyName(event.accessible)}`;
   return info;
 }
 
 function matchEvent(event, matchCriteria) {
@@ -89,17 +89,17 @@ function matchEvent(event, matchCriteria
  *                                                  type
  * @return {Promise}                                promise that resolves to an
  *                                                  event
  */
 function waitForEvent(eventType, matchCriteria) {
   return new Promise(resolve => {
     let eventObserver = {
       observe(subject, topic, data) {
-        if (topic !== 'accessible-event') {
+        if (topic !== "accessible-event") {
           return;
         }
 
         let event = subject.QueryInterface(nsIAccessibleEvent);
         if (Logger.enabled) {
           // Avoid calling eventToString if the logger isn't enabled in order
           // to avoid an intermittent crash (bug 1307645).
           Logger.log(eventToString(event));
@@ -108,53 +108,53 @@ function waitForEvent(eventType, matchCr
         // If event type does not match expected type, skip the event.
         if (event.eventType !== eventType) {
           return;
         }
 
         if (matchEvent(event, matchCriteria)) {
           Logger.log(`Correct event type: ${eventTypeToString(eventType)}`);
           ok(event.accessibleDocument instanceof nsIAccessibleDocument,
-            'Accessible document present.');
+            "Accessible document present.");
 
-          Services.obs.removeObserver(this, 'accessible-event');
+          Services.obs.removeObserver(this, "accessible-event");
           resolve(event);
         }
       }
     };
-    Services.obs.addObserver(eventObserver, 'accessible-event');
+    Services.obs.addObserver(eventObserver, "accessible-event");
   });
 }
 
 class UnexpectedEvents {
   constructor(unexpected) {
     if (unexpected.length) {
       this.unexpected = unexpected;
-      Services.obs.addObserver(this, 'accessible-event');
+      Services.obs.addObserver(this, "accessible-event");
     }
   }
 
   observe(subject, topic, data) {
-    if (topic !== 'accessible-event') {
+    if (topic !== "accessible-event") {
       return;
     }
 
     let event = subject.QueryInterface(nsIAccessibleEvent);
 
     let unexpectedEvent = this.unexpected.find(([etype, criteria]) =>
       etype === event.eventType && matchEvent(event, criteria));
 
     if (unexpectedEvent) {
       ok(false, `Got unexpected event: ${eventToString(event)}`);
     }
   }
 
   stop() {
     if (this.unexpected) {
-      Services.obs.removeObserver(this, 'accessible-event');
+      Services.obs.removeObserver(this, "accessible-event");
     }
   }
 }
 
 /**
  * A helper function that waits for a sequence of accessible events in
  * specified order.
  * @param {Array} events        a list of events to wait (same format as
--- a/accessible/tests/browser/events/browser_test_docload.js
+++ b/accessible/tests/browser/events/browser_test_docload.js
@@ -28,17 +28,17 @@ function urlChecker(url) {
     info(`${event.accessibleDocument.URL} == ${url}`);
     return event.accessibleDocument.URL == url;
   };
 }
 
 async function runTests(browser, accDoc) {
   let onLoadEvents = waitForEvents([
     [EVENT_REORDER, getAccessible(browser)],
-    [EVENT_DOCUMENT_LOAD_COMPLETE, 'body2'],
+    [EVENT_DOCUMENT_LOAD_COMPLETE, "body2"],
     [EVENT_STATE_CHANGE, busyChecker(false)]
   ], [ // unexpected
     [EVENT_DOCUMENT_LOAD_COMPLETE, inIframeChecker("iframe1")],
     [EVENT_STATE_CHANGE, inIframeChecker("iframe1")]
   ]);
 
   browser.loadURI(`data:text/html;charset=utf-8,
     <html><body id="body2">
--- a/accessible/tests/browser/events/browser_test_focus_browserui.js
+++ b/accessible/tests/browser/events/browser_test_focus_browserui.js
@@ -1,18 +1,18 @@
 /* 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";
 
 /* import-globals-from ../../mochitest/states.js */
 /* import-globals-from ../../mochitest/role.js */
-loadScripts({ name: 'states.js', dir: MOCHITESTS_DIR },
-            { name: 'role.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "states.js", dir: MOCHITESTS_DIR },
+            { name: "role.js", dir: MOCHITESTS_DIR });
 
 async function runTests(browser, accDoc) {
   let onFocus = waitForEvent(EVENT_FOCUS, "input");
   EventUtils.synthesizeKey("VK_TAB", {}, browser.ownerGlobal);
   let evt = await onFocus;
   testStates(evt.accessible, STATE_FOCUSED);
 
   onFocus = waitForEvent(EVENT_FOCUS, "buttonInputDoc");
--- a/accessible/tests/browser/events/browser_test_focus_dialog.js
+++ b/accessible/tests/browser/events/browser_test_focus_dialog.js
@@ -1,18 +1,18 @@
 /* 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