Merge draft head draft
authorGregory Szorc <gps@mozilla.com>
Fri, 04 Aug 2017 16:05:44 -0700
changeset 640344 7700a78bcce660b6849fb844c44a2826f8a52377
parent 640343 e1ff1895168bd16361e7bf75f092aebb8625e9c6 (diff)
parent 619221 f01cc5f42f4878a005754132a473c1e0ea245453 (current diff)
child 640345 bdfb2d4a3a57ce01e06d02921c170e35500a623a
push id72398
push usergszorc@mozilla.com
push dateFri, 04 Aug 2017 23:14:39 +0000
milestone57.0a1
Merge draft head
--- a/.eslintignore
+++ b/.eslintignore
@@ -133,18 +133,19 @@ devtools/server/tests/browser/storage-*.
 !devtools/server/tests/browser/storage-unsecured-iframe.html
 devtools/server/tests/browser/stylesheets-nested-iframes.html
 devtools/server/tests/unit/xpcshell_debugging_script.js
 devtools/shared/platform/content/test/test_clipboard.html
 devtools/shared/qrcode/tests/mochitest/test_decode.html
 devtools/shared/tests/mochitest/*.html
 devtools/shared/webconsole/test/test_*.html
 
-# Ignore devtools pre-processed files
+# Ignore devtools preferences files
 devtools/client/preferences/**
+devtools/shim/devtools-startup-prefs.js
 
 # Ignore devtools third-party libs
 devtools/shared/jsbeautify/*
 devtools/shared/acorn/*
 devtools/shared/gcli/source/*
 devtools/shared/node-properties/*
 devtools/shared/pretty-fast/*
 devtools/shared/sourcemap/*
@@ -334,28 +335,28 @@ toolkit/components/help/**
 
 # Intentionally invalid JS
 toolkit/components/workerloader/tests/moduleF-syntax-error.js
 
 # Tests old non-star function generators
 toolkit/modules/tests/xpcshell/test_task.js
 
 # Not yet updated
-toolkit/components/osfile/**
 toolkit/components/url-classifier/**
 
 # External code:
 toolkit/components/microformats/test/**
 toolkit/components/microformats/microformat-shiv.js
 toolkit/components/reader/Readability.js
 toolkit/components/reader/JSDOMParser.js
 
 # Uses preprocessing
 toolkit/content/widgets/wizard.xml
 toolkit/components/jsdownloads/src/DownloadIntegration.jsm
+toolkit/components/osfile/osfile.jsm
 toolkit/components/urlformatter/nsURLFormatter.js
 toolkit/modules/AppConstants.jsm
 toolkit/mozapps/downloads/nsHelperAppDlg.js
 toolkit/mozapps/update/tests/data/xpcshellConstantsPP.js
 
 # Third party
 toolkit/modules/third_party/**
 third_party/**
--- a/.hgtags
+++ b/.hgtags
@@ -128,8 +128,9 @@ 68d3781deda0d4d58ec9877862830db89669b3a5
 1c6385ae1fe7e37d8f23f958ce14582f07af729e FIREFOX_AURORA_48_BASE
 d98f20c25feeac4dd7ebbd1c022957df1ef58af4 FIREFOX_AURORA_49_BASE
 465d150bc8be5bbf9f02a8607d4552b6a5e1697c FIREFOX_AURORA_50_BASE
 fc69febcbf6c0dcc4b3dfc7a346d8d348798a65f FIREFOX_AURORA_51_BASE
 1196bf3032e1bce1fb07a01fd9082a767426c5fb FIREFOX_AURORA_52_BASE
 f80dc9fc34680105b714a49b4704bb843f5f7004 FIREFOX_AURORA_53_BASE
 6583496f169cd8a13c531ed16e98e8bf313eda8e FIREFOX_AURORA_54_BASE
 f9605772a0c9098ed1bcaa98089b2c944ed69e9b FIREFOX_BETA_55_BASE
+320642944e42a889db13c6c55b404e32319d4de6 FIREFOX_BETA_56_BASE
--- a/CLOBBER
+++ b/CLOBBER
@@ -17,9 +17,9 @@
 #
 # Modifying this file will now automatically clobber the buildbot machines \o/
 #
 
 # Are you updating CLOBBER because you think it's needed for your WebIDL
 # changes to stick? As of bug 928195, this shouldn't be necessary! Please
 # don't change CLOBBER for WebIDL changes any more.
 
-Bug 1353650 - Update to ICU 59 requires clobber
+Merge day clobber
\ No newline at end of file
--- a/accessible/.eslintrc.js
+++ b/accessible/.eslintrc.js
@@ -3,22 +3,15 @@
 module.exports = {
   "rules": {
     // 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",
-    "spaced-comment": "off",
   }
 };
--- a/accessible/base/nsCoreUtils.cpp
+++ b/accessible/base/nsCoreUtils.cpp
@@ -439,17 +439,17 @@ nsCoreUtils::IsErrorPage(nsIDocument *aD
 {
   nsIURI *uri = aDocument->GetDocumentURI();
   bool isAboutScheme = false;
   uri->SchemeIs("about", &isAboutScheme);
   if (!isAboutScheme)
     return false;
 
   nsAutoCString path;
-  uri->GetPath(path);
+  uri->GetPathQueryRef(path);
 
   NS_NAMED_LITERAL_CSTRING(neterror, "neterror");
   NS_NAMED_LITERAL_CSTRING(certerror, "certerror");
 
   return StringBeginsWith(path, neterror) || StringBeginsWith(path, certerror);
 }
 
 bool
--- a/accessible/generic/DocAccessible.cpp
+++ b/accessible/generic/DocAccessible.cpp
@@ -2169,17 +2169,16 @@ DocAccessible::DoARIAOwnsRelocation(Acce
 }
 
 void
 DocAccessible::PutChildrenBack(nsTArray<RefPtr<Accessible> >* aChildren,
                                uint32_t aStartIdx)
 {
   MOZ_ASSERT(aStartIdx <= aChildren->Length(), "Wrong removal index");
 
-  nsTArray<RefPtr<Accessible> > containers;
   for (auto idx = aStartIdx; idx < aChildren->Length(); idx++) {
     Accessible* child = aChildren->ElementAt(idx);
     if (!child->IsInDocument()) {
       continue;
     }
 
     // Remove the child from the owner
     Accessible* owner = child->Parent();
@@ -2191,21 +2190,22 @@ DocAccessible::PutChildrenBack(nsTArray<
 #ifdef A11Y_LOG
     logging::TreeInfo("aria owns put child back", 0,
                       "old parent", owner, "child", child, nullptr);
 #endif
 
     // Unset relocated flag to find an insertion point for the child.
     child->SetRelocated(false);
 
+    nsIContent* content = child->GetContent();
     int32_t idxInParent = -1;
-    Accessible* origContainer = GetContainerAccessible(child->GetContent());
+    Accessible* origContainer = AccessibleOrTrueContainer(content->GetParentNode());
     if (origContainer) {
       TreeWalker walker(origContainer);
-      if (walker.Seek(child->GetContent())) {
+      if (walker.Seek(content)) {
         Accessible* prevChild = walker.Prev();
         if (prevChild) {
           idxInParent = prevChild->IndexInParent() + 1;
           MOZ_DIAGNOSTIC_ASSERT(origContainer == prevChild->Parent(), "Broken tree");
           origContainer = prevChild->Parent();
         }
         else {
           idxInParent = 0;
--- 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) {
+  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();
           }
+          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();
           }
+          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();
           }
+          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) {
+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
@@ -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/. */
 
 /* exported GestureSettings, GestureTracker */
 
-/******************************************************************************
+/** ****************************************************************************
   All gestures have the following pathways when being resolved(v)/rejected(x):
                Tap -> DoubleTap        (x)
                    -> Dwell            (x)
                    -> Swipe            (x)
 
          DoubleTap -> TripleTap        (x)
                    -> TapHold          (x)
 
@@ -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,106 @@ 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.
+  // 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'});
-      }
-      else if (itemno.value == itemof.value) {
+        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 +719,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 +768,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 +845,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 +899,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 +966,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);
     }
@@ -42,22 +42,21 @@ function BaseTraversalRule(aRoles, aMatc
 }
 
 BaseTraversalRule.prototype = {
     getMatchRoles: function BaseTraversalRule_getmatchRoles(aRoles) {
       aRoles.value = this._matchRoles;
       return aRoles.value.length;
     },
 
-    match: function BaseTraversalRule_match(aAccessible)
-    {
+    match: function BaseTraversalRule_match(aAccessible) {
       let role = aAccessible.role;
       if (role == Roles.INTERNAL_FRAME) {
         return (Utils.getMessageManager(aAccessible.DOMNode)) ?
-          Filters.MATCH  | Filters.IGNORE_SUBTREE : Filters.IGNORE;
+          Filters.MATCH | Filters.IGNORE_SUBTREE : Filters.IGNORE;
       }
 
       let matchResult =
         (this._explicitMatchRoles.has(role) || !this._explicitMatchRoles.size) ?
         this._matchFunc(aAccessible) : Filters.IGNORE;
 
       // If we are on a label that nests a checkbox/radio we should land on it.
       // It is a bigger touch target, and it reduces clutter.
@@ -189,24 +188,23 @@ this.TraversalRules = { // jshint ignore
 
   SimpleOnScreen: new BaseTraversalRule(
     gSimpleTraversalRoles, gSimpleMatchFunc,
     Prefilters.DEFUNCT | Prefilters.INVISIBLE | Prefilters.ARIA_HIDDEN |
     Prefilters.TRANSPARENT | Prefilters.OFFSCREEN),
 
   Anchor: new BaseTraversalRule(
     [Roles.LINK],
-    function Anchor_match(aAccessible)
-    {
+    function Anchor_match(aAccessible) {
       // We want to ignore links, only focus named anchors.
       if (Utils.getState(aAccessible).contains(States.LINKED)) {
         return Filters.IGNORE;
-      } else {
-        return Filters.MATCH;
       }
+      return Filters.MATCH;
+
     }),
 
   Button: new BaseTraversalRule(
     [Roles.PUSHBUTTON,
      Roles.SPINBUTTON,
      Roles.TOGGLE_BUTTON,
      Roles.BUTTONDROPDOWN,
      Roles.BUTTONDROPDOWNGRID]),
@@ -227,23 +225,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]),
@@ -279,24 +277,23 @@ this.TraversalRules = { // jshint ignore
     }),
 
   ListItem: new BaseTraversalRule(
     [Roles.LISTITEM,
      Roles.TERM]),
 
   Link: new BaseTraversalRule(
     [Roles.LINK],
-    function Link_match(aAccessible)
-    {
+    function Link_match(aAccessible) {
       // We want to ignore anchors, only focus real links.
       if (Utils.getState(aAccessible).contains(States.LINKED)) {
         return Filters.MATCH;
-      } else {
-        return Filters.IGNORE;
       }
+      return Filters.IGNORE;
+
     }),
 
   /* For TalkBack's "Control" granularity. Form conrols and links */
   Control: new BaseTraversalRule(
     [Roles.PUSHBUTTON,
      Roles.SPINBUTTON,
      Roles.TOGGLE_BUTTON,
      Roles.BUTTONDROPDOWN,
@@ -309,18 +306,17 @@ this.TraversalRules = { // jshint ignore
      Roles.RADIOBUTTON,
      Roles.RADIO_MENU_ITEM,
      Roles.SLIDER,
      Roles.CHECKBUTTON,
      Roles.CHECK_MENU_ITEM,
      Roles.SWITCH,
      Roles.LINK,
      Roles.MENUITEM],
-    function Control_match(aAccessible)
-    {
+    function Control_match(aAccessible) {
       // We want to ignore anchors, only focus real links.
       if (aAccessible.role == Roles.LINK &&
           !Utils.getState(aAccessible).contains(States.LINKED)) {
         return Filters.IGNORE;
       }
       return Filters.MATCH;
     }),
 
@@ -356,17 +352,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,
@@ -404,14 +400,14 @@ this.TraversalHelper = {
           aVirtualCursor.modalRoot = null;
         } else {
           // If we failed to step to another container, break and return false.
           break;
         }
       }
 
       return moved;
-    } else {
-      return aVirtualCursor[aMethod](rule);
     }
+    return aVirtualCursor[aMethod](rule);
+
   }
 
 };
--- 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;
   },
 
@@ -259,22 +259,22 @@ this.Utils = { // jshint ignore:line
     }
   },
 
   getState: function getState(aAccessibleOrEvent) {
     if (aAccessibleOrEvent instanceof Ci.nsIAccessibleStateChangeEvent) {
       return new State(
         aAccessibleOrEvent.isExtraState ? 0 : aAccessibleOrEvent.state,
         aAccessibleOrEvent.isExtraState ? aAccessibleOrEvent.state : 0);
-    } else {
+    }
       let state = {};
       let extState = {};
       aAccessibleOrEvent.getState(state, extState);
       return new State(state.value, extState.value);
-    }
+
   },
 
   getAttributes: function getAttributes(aAccessible) {
     let attributes = {};
 
     if (aAccessible && aAccessible.attributes) {
       let attributesEnum = aAccessible.attributes.enumerate();
 
@@ -359,43 +359,43 @@ 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;
       }
     }
     return count;
   },
 
   inHiddenSubtree: function inHiddenSubtree(aAccessible) {
-    for (let acc=aAccessible; acc; acc=acc.parent) {
+    for (let acc = aAccessible; acc; acc = acc.parent) {
       if (this.isHidden(acc)) {
         return true;
       }
     }
     return false;
   },
 
   isAliveAndVisible: function isAliveAndVisible(aAccessible, aIsOnScreen) {
@@ -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/mac/AccessibleWrap.mm
+++ b/accessible/mac/AccessibleWrap.mm
@@ -4,16 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "DocAccessible.h"
 #include "nsObjCExceptions.h"
 
 #include "Accessible-inl.h"
 #include "nsAccUtils.h"
 #include "Role.h"
+#include "gfxPlatform.h"
 
 #import "mozAccessible.h"
 #import "mozActionElements.h"
 #import "mozHTMLAccessible.h"
 #import "mozTableAccessible.h"
 #import "mozTextAccessible.h"
 
 using namespace mozilla;
@@ -181,16 +182,22 @@ AccessibleWrap::AncestorIsFlat()
   return false;
 }
 
 void
 a11y::FireNativeEvent(mozAccessible* aNativeAcc, uint32_t aEventType)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
 
+  // Under headless mode we don't have access to a native window, so we skip
+  // dispatching native events.
+  if (gfxPlatform::IsHeadless()) {
+    return;
+  }
+
   switch (aEventType) {
     case nsIAccessibleEvent::EVENT_FOCUS:
       [aNativeAcc didReceiveFocus];
       break;
     case nsIAccessibleEvent::EVENT_VALUE_CHANGE:
     case nsIAccessibleEvent::EVENT_TEXT_VALUE_CHANGE:
       [aNativeAcc valueDidChange];
       break;
--- a/accessible/tests/browser/.eslintrc.js
+++ b/accessible/tests/browser/.eslintrc.js
@@ -13,17 +13,17 @@ module.exports = {
     "block-scoped-var": "error",
     "camelcase": "error",
     "comma-dangle": ["error", "never"],
     "complexity": ["error", 20],
     "consistent-this": "off",
     "curly": ["error", "multi-line"],
     "default-case": "off",
     "dot-location": ["error", "property"],
-    "dot-notation": "error",
+
     "eqeqeq": "off",
     "func-names": "off",
     "func-style": "off",
     "generator-star-spacing": "off",
     "handle-callback-err": ["error", "er"],
     "indent": ["error", 2, {"SwitchCase": 1}],
     "max-nested-callbacks": ["error", 4],
     "max-params": "off",
@@ -82,17 +82,16 @@ module.exports = {
     "space-in-parens": ["error", "never"],
     "space-unary-word-ops": "off",
     "strict": ["error", "global"],
     "valid-jsdoc": "off",
     "vars-on-top": "off",
     "wrap-iife": "off",
     "wrap-regex": "off",
     "yoda": "error",
-
     "guard-for-in": "off",
     "newline-after-var": "off",
     "no-alert": "off",
     "no-eq-null": "off",
     "no-func-assign": "off",
     "no-implied-eval": "off",
     "no-inner-declarations": "off",
     "no-invalid-regexp": "off",
--- 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 () {
+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 () {
+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 () {
+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 () {
+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 () {
+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 () {
+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');
+add_task(async function() {
+  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 () {
+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 () {
+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 () {
+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 () {
+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 () {
+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 () {
+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 () {
+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');
+add_task(async function() {
+  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');
+  async function(browser, accDoc) {
+    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,83 +1,83 @@
 /* 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]);
   }
 }
 
 /**
  * Test caching of relations between accessible objects.
  */
 addAccessibleTask(`
   <div id="dependant1">label</div>
   <div id="dependant2">label2</div>
   <div role="checkbox" id="host"></div>`,
-  async function (browser, accDoc) {
+  async function(browser, accDoc) {
     for (let spec of attrRelationsSpec) {
       await testRelated(browser, accDoc, ...spec);
     }
   }
 );
--- 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);
@@ -106,14 +106,14 @@ 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);
+  async function(browser, accDoc) {
+    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,135 +1,135 @@
 /* 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>
   <select id="select">
     <option>1st</option>
     <option>2nd</option>
     <option>3rd</option>
   </select>
   <input id="combobox" role="combobox" aria-autocomplete="inline">
   <progress id="progress" value="22" max="100"></progress>
   <input type="range" id="range" min="0" max="10" value="6">`,
-  async function (browser, accDoc) {
+  async function(browser, accDoc) {
     for (let { desc, id, action, attrs, expected, waitFor } of valueTests) {
       info(desc);
       let acc = findAccessibleChildByID(accDoc, id);
       let onUpdate;
 
       if (waitFor) {
         onUpdate = waitForEvent(waitFor, id);
       }
--- 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
@@ -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";
 
 function busyChecker(isBusy) {
-  return function (event) {
+  return function(event) {
     let scEvent;
     try {
       scEvent = event.QueryInterface(nsIAccessibleStateChangeEvent);
     } catch (e) {
       return false;
     }
 
     return scEvent.state == STATE_BUSY && scEvent.isEnabled == isBusy;
   };
 }
 
 function inIframeChecker(iframeId) {
-  return function (event) {
+  return function(event) {
     return getAccessibleDOMNodeID(event.accessibleDocument.parent) == iframeId;
   };
 }
 
 function urlChecker(url) {
-  return function (event) {
+  return function(event) {
     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 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, "button");
   await ContentTask.spawn(browser, {}, () => {
     content.document.getElementById("button").focus();
   });
   let button = (await onFocus).accessible;
   testStates(button, STATE_FOCUSED);
--- a/accessible/tests/browser/events/head.js
+++ b/accessible/tests/browser/events/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', 'layout.js');
+loadScripts({ name: "common.js", dir: MOCHITESTS_DIR }, "events.js", "layout.js");
--- a/accessible/tests/browser/head.js
+++ b/accessible/tests/browser/head.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";
 
 /* exported initPromise, shutdownPromise, waitForEvent, setE10sPrefs,
             unsetE10sPrefs, forceGC */
 
 /**
  * Set e10s related preferences in the test environment.
  * @return {Promise} promise that resolves when preferences are set.
  */
 function setE10sPrefs() {
   return new Promise(resolve =>
     SpecialPowers.pushPrefEnv({
       set: [
-        ['browser.tabs.remote.autostart', true],
-        ['browser.tabs.remote.force-enable', true],
-        ['extensions.e10sBlocksEnabling', false]
+        ["browser.tabs.remote.autostart", true],
+        ["browser.tabs.remote.force-enable", true],
+        ["extensions.e10sBlocksEnabling", false]
       ]
     }, resolve));
 }
 
 /**
  * Unset e10s related preferences in the test environment.
  * @return {Promise} promise that resolves when preferences are unset.
  */
@@ -30,30 +30,30 @@ function unsetE10sPrefs() {
   return new Promise(resolve => {
     SpecialPowers.popPrefEnv(resolve);
   });
 }
 
 // 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);
 
 /**
  * Returns a promise that resolves when 'a11y-init-or-shutdown' event is fired.
  * @return {Promise} event promise evaluating to event's data
  */
 function a11yInitOrShutdownPromise() {
   return new Promise(resolve => {
     let observe = (subject, topic, data) => {
-      Services.obs.removeObserver(observe, 'a11y-init-or-shutdown');
+      Services.obs.removeObserver(observe, "a11y-init-or-shutdown");
       resolve(data);
     };
-    Services.obs.addObserver(observe, 'a11y-init-or-shutdown');
+    Services.obs.addObserver(observe, "a11y-init-or-shutdown");
   });
 }
 
 /**
  * Returns a promise that resolves when 'a11y-init-or-shutdown' event is fired
  * in content.
  * @param  {Object}   browser  current "tabbrowser" element
  * @return {Promise}  event    promise evaluating to event's data
@@ -80,56 +80,56 @@ function promiseOK(promise, expected) {
  *                                  initialized in content process.
  * @return {Promise}                promise that resolves when the accessibility
  *                                  service initialized correctly.
  */
 function initPromise(contentBrowser) {
   let a11yInitPromise = contentBrowser ?
     contentA11yInitOrShutdownPromise(contentBrowser) :
     a11yInitOrShutdownPromise();
-  return promiseOK(a11yInitPromise, '1').then(
-    () => ok(true, 'Service initialized correctly'),
-    () => ok(false, 'Service shutdown incorrectly'));
+  return promiseOK(a11yInitPromise, "1").then(
+    () => ok(true, "Service initialized correctly"),
+    () => ok(false, "Service shutdown incorrectly"));
 }
 
 /**
  * Checks and returns a promise that resolves when accessibility service is
  * shut down with the correct flag.
  * @param  {?Object} contentBrowser optinal remove browser object that indicates
  *                                  that accessibility service is expected to be
  *                                  shut down in content process.
  * @return {Promise}                promise that resolves when the accessibility
  *                                  service shuts down correctly.
  */
 function shutdownPromise(contentBrowser) {
   let a11yShutdownPromise = contentBrowser ?
     contentA11yInitOrShutdownPromise(contentBrowser) :
     a11yInitOrShutdownPromise();
-  return promiseOK(a11yShutdownPromise, '0').then(
-    () => ok(true, 'Service shutdown correctly'),
-    () => ok(false, 'Service initialized incorrectly'));
+  return promiseOK(a11yShutdownPromise, "0").then(
+    () => ok(true, "Service shutdown correctly"),
+    () => ok(false, "Service initialized incorrectly"));
 }
 
 /**
  * Simpler verions of waitForEvent defined in
  * accessible/tests/browser/events.js
  */
 function waitForEvent(eventType, expectedId) {
   return new Promise(resolve => {
     let eventObserver = {
       observe(subject) {
         let event = subject.QueryInterface(Ci.nsIAccessibleEvent);
         if (event.eventType === eventType &&
             event.accessible.id === expectedId) {
-          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");
   });
 }
 
 /**
  * Force garbage collection.
  */
 function forceGC() {
   SpecialPowers.gc();
--- a/accessible/tests/browser/scroll/browser_test_zoom_text.js
+++ b/accessible/tests/browser/scroll/browser_test_zoom_text.js
@@ -1,37 +1,37 @@
 /* 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/layout.js */
-loadScripts({ name: 'layout.js', dir: MOCHITESTS_DIR });
+loadScripts({ name: "layout.js", dir: MOCHITESTS_DIR });
 
 async function runTests(browser, accDoc) {
-  loadFrameScripts(browser, { name: 'layout.js', dir: MOCHITESTS_DIR });
+  loadFrameScripts(browser, { name: "layout.js", dir: MOCHITESTS_DIR });
 
   let paragraph = findAccessibleChildByID(accDoc, "paragraph", [nsIAccessibleText]);
   let offset = 64; // beginning of 4th stanza
 
-  let [x /*,y*/] = getPos(paragraph);
+  let [x /* ,y*/] = getPos(paragraph);
   let [docX, docY] = getPos(accDoc);
 
   paragraph.scrollSubstringToPoint(offset, offset,
                                    COORDTYPE_SCREEN_RELATIVE, docX, docY);
   testTextPos(paragraph, offset, [x, docY], COORDTYPE_SCREEN_RELATIVE);
 
   await ContentTask.spawn(browser, {}, () => {
     zoomDocument(document, 2.0);
   });
 
   paragraph = findAccessibleChildByID(accDoc, "paragraph2", [nsIAccessibleText]);
   offset = 52; // // beginning of 4th stanza
-  [x /*,y*/] = getPos(paragraph);
+  [x /* ,y*/] = getPos(paragraph);
   paragraph.scrollSubstringToPoint(offset, offset,
                                    COORDTYPE_SCREEN_RELATIVE, docX, docY);
   testTextPos(paragraph, offset, [x, docY], COORDTYPE_SCREEN_RELATIVE);
 }
 
 /**
  * Test caching of accessible object states
  */
--- a/accessible/tests/browser/scroll/head.js
+++ b/accessible/tests/browser/scroll/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/shared-head.js
+++ b/accessible/tests/browser/shared-head.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";
 
 /* import-globals-from ../mochitest/common.js */
 /* import-globals-from events.js */
 
 /* exported Logger, MOCHITESTS_DIR, invokeSetAttribute, invokeFocus,
             invokeSetStyle, getAccessibleDOMNodeID, getAccessibleTagName,
             addAccessibleTask, findAccessibleChildByID, isDefunct,
             CURRENT_CONTENT_DIR, loadScripts, loadFrameScripts, snippetToURL,
             Cc, Cu, arrayFromChildren */
 
 const { interfaces: Ci, utils: Cu, classes: Cc } = Components;
 
 /**
  * Current browser test directory path used to load subscripts.
  */
 const CURRENT_DIR =
-  'chrome://mochitests/content/browser/accessible/tests/browser/';
+  "chrome://mochitests/content/browser/accessible/tests/browser/";
 /**
  * A11y mochitest directory where we find common files used in both browser and
  * plain tests.
  */
 const MOCHITESTS_DIR =
-  'chrome://mochitests/content/a11y/accessible/tests/mochitest/';
+  "chrome://mochitests/content/a11y/accessible/tests/mochitest/";
 /**
  * A base URL for test files used in content.
  */
 const CURRENT_CONTENT_DIR =
-  'http://example.com/browser/accessible/tests/browser/';
+  "http://example.com/browser/accessible/tests/browser/";
 
 const LOADED_FRAMESCRIPTS = new Map();
 
 /**
  * Used to dump debug information.
  */
 let Logger = {
   /**
@@ -158,33 +158,33 @@ function invokeFocus(browser, id) {
 }
 
 /**
  * Load a list of scripts into the test
  * @param {Array} scripts  a list of scripts to load
  */
 function loadScripts(...scripts) {
   for (let script of scripts) {
-    let path = typeof script === 'string' ? `${CURRENT_DIR}${script}` :
+    let path = typeof script === "string" ? `${CURRENT_DIR}${script}` :
       `${script.dir}${script.name}`;
     Services.scriptloader.loadSubScript(path, this);
   }
 }
 
 /**
  * Load a list of frame scripts into test's content.
  * @param {Object} browser   browser element that content belongs to
  * @param {Array}  scripts   a list of scripts to load into content
  */
 function loadFrameScripts(browser, ...scripts) {
   let mm = browser.messageManager;
   for (let script of scripts) {
     let frameScript;
-    if (typeof script === 'string') {
-      if (script.includes('.js')) {
+    if (typeof script === "string") {
+      if (script.includes(".js")) {
         // If script string includes a .js extention, assume it is a script
         // path.
         frameScript = `${CURRENT_DIR}${script}`;
       } else {
         // Otherwise it is a serealized script.
         frameScript = `data:,${script}`;
       }
     } else {
@@ -209,17 +209,17 @@ function loadFrameScripts(browser, ...sc
  * Takes an HTML snippet and returns an encoded URI for a full document
  * with the snippet.
  * @param {String} snippet   a markup snippet.
  * @param {Object} bodyAttrs extra attributes to use in the body tag. Default is
  *                           { id: "body "}.
  * @return {String} a base64 encoded data url of the document container the
  *                  snippet.
  **/
-function snippetToURL(snippet, bodyAttrs={}) {
+function snippetToURL(snippet, bodyAttrs = {}) {
   let attrs = Object.assign({}, { id: "body" }, bodyAttrs);
   let attrsString = Object.entries(attrs).map(
     ([attr, value]) => `${attr}=${JSON.stringify(value)}`).join(" ");
   let encodedDoc = btoa(
     `<html>
       <head>
         <meta charset="utf-8"/>
         <title>Accessibility Test</title>
@@ -237,32 +237,32 @@ function snippetToURL(snippet, bodyAttrs
  *                                       data URL or markup snippet that is used
  *                                       to test content with
  * @param  {Function|AsyncFunction} task a generator or a function with tests to
  *                                       run
  */
 function addAccessibleTask(doc, task) {
   add_task(async function() {
     let url;
-    if (doc.includes('doc_')) {
+    if (doc.includes("doc_")) {
       url = `${CURRENT_CONTENT_DIR}e10s/${doc}`;
     } else {
       url = snippetToURL(doc);
     }
 
     registerCleanupFunction(() => {
-      let observers = Services.obs.enumerateObservers('accessible-event');
+      let observers = Services.obs.enumerateObservers("accessible-event");
       while (observers.hasMoreElements()) {
         Services.obs.removeObserver(
           observers.getNext().QueryInterface(Ci.nsIObserver),
-          'accessible-event');
+          "accessible-event");
       }
     });
 
-    let onDocLoad = waitForEvent(EVENT_DOCUMENT_LOAD_COMPLETE, 'body');
+    let onDocLoad = waitForEvent(EVENT_DOCUMENT_LOAD_COMPLETE, "body");
 
     await BrowserTestUtils.withNewTab({
       gBrowser,
       url: url
     }, async function(browser) {
       registerCleanupFunction(() => {
         if (browser) {
           let tab = gBrowser.getTabForBrowser(browser);
@@ -270,18 +270,18 @@ function addAccessibleTask(doc, task) {
             gBrowser.removeTab(tab);
           }
         }
       });
 
       await SimpleTest.promiseFocus(browser);
 
       loadFrameScripts(browser,
-        'let { document, window, navigator } = content;',
-        { name: 'common.js', dir: MOCHITESTS_DIR });
+        "let { document, window, navigator } = content;",
+        { name: "common.js", dir: MOCHITESTS_DIR });
 
       Logger.log(
         `e10s enabled: ${Services.appinfo.browserTabsRemoteAutostart}`);
       Logger.log(`Actually remote browser: ${browser.isRemoteBrowser}`);
 
       let event = await onDocLoad;
       await task(browser, event.accessible);
     });
--- a/accessible/tests/browser/states/browser_test_link.js
+++ b/accessible/tests/browser/states/browser_test_link.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 */
 /* 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 });
 
 async function runTests(browser, accDoc) {
   let getAcc = id => findAccessibleChildByID(accDoc, id);
 
   // a: no traversed state
   testStates(getAcc("link_traversed"), 0, 0, STATE_TRAVERSED);
 
   let onStateChanged = waitForEvent(EVENT_STATE_CHANGE, "link_traversed");
   let newWinOpened = BrowserTestUtils.waitForNewWindow();
 
-  await BrowserTestUtils.synthesizeMouse('#link_traversed',
+  await BrowserTestUtils.synthesizeMouse("#link_traversed",
     1, 1, { shiftKey: true }, browser);
 
   await onStateChanged;
   testStates(getAcc("link_traversed"), STATE_TRAVERSED);
 
   let newWin = await newWinOpened;
   await BrowserTestUtils.closeWindow(newWin);
 }
--- a/accessible/tests/browser/states/browser_test_visibility.js
+++ b/accessible/tests/browser/states/browser_test_visibility.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 */
 /* 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 });
 
 async function runTest(browser, accDoc) {
   let getAcc = id => findAccessibleChildByID(accDoc, id);
 
   testStates(getAcc("div"), 0, 0, STATE_INVISIBLE | STATE_OFFSCREEN);
 
   let input = getAcc("input_scrolledoff");
   testStates(input, STATE_OFFSCREEN, 0, STATE_INVISIBLE);
 
   // scrolled off item (twice)
   let lastLi = getAcc("li_last");
   testStates(lastLi, STATE_OFFSCREEN, 0, STATE_INVISIBLE);
 
   // scroll into view the item
   await ContentTask.spawn(browser, {}, () => {
-    content.document.getElementById('li_last').scrollIntoView(true);
+    content.document.getElementById("li_last").scrollIntoView(true);
   });
   testStates(lastLi, 0, 0, STATE_OFFSCREEN | STATE_INVISIBLE);
 
   // first item is scrolled off now (testcase for bug 768786)
   let firstLi = getAcc("li_first");
   testStates(firstLi, STATE_OFFSCREEN, 0, STATE_INVISIBLE);
 
   let newTab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
--- a/accessible/tests/browser/states/head.js
+++ b/accessible/tests/browser/states/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/tree/browser.ini
+++ b/accessible/tests/browser/tree/browser.ini
@@ -2,8 +2,9 @@
 skip-if = e10s && os == 'win' && release_or_beta
 support-files =
   head.js
   !/accessible/tests/browser/events.js
   !/accessible/tests/browser/shared-head.js
   !/accessible/tests/mochitest/*.js
 
 [browser_test_aria_owns.js]
+[browser_test_aria_owns_select.js]
new file mode 100644
--- /dev/null
+++ b/accessible/tests/browser/tree/browser_test_aria_owns_select.js
@@ -0,0 +1,45 @@
+/* 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";
+
+function testChildrenIds(acc, expectedIds) {
+  let ids = arrayFromChildren(acc).map(child => getAccessibleDOMNodeID(child));
+  Assert.deepEqual(ids, expectedIds,
+    `Children for ${getAccessibleDOMNodeID(acc)} are wrong.`);
+}
+
+async function runTests(browser, accDoc) {
+  let div = findAccessibleChildByID(accDoc, "div");
+  let select = findAccessibleChildByID(accDoc, "select");
+
+  testChildrenIds(div, ["b"]);
+  testChildrenIds(select.firstChild, ["a"]);
+
+  let onReorders = waitForEvents([
+    [EVENT_REORDER, "div"],
+    [EVENT_REORDER,
+      evt => getAccessibleDOMNodeID(evt.accessible.parent) == "select"]
+  ]);
+
+  await ContentTask.spawn(browser, null, async function() {
+    document.getElementById("div").removeAttribute("aria-owns");
+  });
+
+  await onReorders;
+
+  testChildrenIds(div, []);
+  testChildrenIds(select.firstChild, ["a", "b"]);
+}
+
+/**
+ * Test caching of accessible object states
+ */
+addAccessibleTask(`
+  <div id="div" role="group" aria-owns="b"></div>
+  <select id="select">
+    <option id="a"></option>
+    <option id="b"></option>
+  </select>
+    `, runTests);
--- a/accessible/tests/browser/tree/head.js
+++ b/accessible/tests/browser/tree/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', 'layout.js');
+loadScripts({ name: "common.js", dir: MOCHITESTS_DIR }, "events.js", "layout.js");
--- a/accessible/tests/crashtests/448064.xhtml
+++ b/accessible/tests/crashtests/448064.xhtml
@@ -22,49 +22,49 @@ function dumpAccessibleNode(aNode, level
   var msg = "";
 
   try {
     msg += "name=\"" + aNode.name + "\" ";
   } catch (e) {
     msg += " noName ";
   }
 
-  dump(msg + '\n');
+  dump(msg + "\n");
 }
 
 
 function dumpAccessibleTree(aNode, level) {
   level = level || 0;
 
   dumpAccessibleNode(aNode, level);
   try {
     var child = aNode.firstChild;
     while (child) {
       dumpAccessibleTree(child, level + 1);
       child = child.nextSibling;
     }
   } catch (e) {
-    dump("Error visiting child nodes: " + e + '\n');
+    dump("Error visiting child nodes: " + e + "\n");
   }
 }
 
 function A(o) {
-  var acc = SpecialPowers.Cc['@mozilla.org/accessibilityService;1']
+  var acc = SpecialPowers.Cc["@mozilla.org/accessibilityService;1"]
                          .getService(SpecialPowers.Ci.nsIAccessibilityService);
   return acc.getAccessibleFor(o);
 }
 
 function beginAccessible() {
   dumpAccessibleTree(A(document), 0);
 }
 setTimeout(beginAccessible, 100);
 
 
 setTimeout(doe, 200);
 function doe() {
-   document.getElementById('mw_a').appendChild(document.getElementById('mw_b'));
-   document.getElementById('mw_c').appendChild(document.getElementById('mw_d'));
-   document.getElementById('mw_e').appendChild(document.getElementById('mw_f'));
-   document.getElementById('mw_g').appendChild(document.getElementById('mw_b'));
+   document.getElementById("mw_a").appendChild(document.getElementById("mw_b"));
+   document.getElementById("mw_c").appendChild(document.getElementById("mw_d"));
+   document.getElementById("mw_e").appendChild(document.getElementById("mw_f"));
+   document.getElementById("mw_g").appendChild(document.getElementById("mw_b"));
 }
 </script>
 </body>
 </html>
--- a/accessible/tests/mochitest/actions.js
+++ b/accessible/tests/mochitest/actions.js
@@ -1,21 +1,21 @@
-////////////////////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////////////////
 // Event constants
 
 const MOUSEDOWN_EVENT = 1;
 const MOUSEUP_EVENT = 2;
 const CLICK_EVENT = 4;
 const COMMAND_EVENT = 8;
 const FOCUS_EVENT = 16;
 
 const CLICK_EVENTS = MOUSEDOWN_EVENT | MOUSEUP_EVENT | CLICK_EVENT;
 const XUL_EVENTS = CLICK_EVENTS | COMMAND_EVENT;
 
-////////////////////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////////////////
 // Public functions
 
 /**
  * Test default accessible actions.
  *
  * Action tester interface is:
  *
  *  var actionObj = {
@@ -42,18 +42,17 @@ const XUL_EVENTS = CLICK_EVENTS | COMMAN
  *    // [optional] an array of invoker's checker objects (see eventQueue
  *    // constructor events.js)
  *    get eventSeq() {}
  *  };
  *
  *
  * @param  aArray [in] an array of action cheker objects
  */
-function testActions(aArray)
-{
+function testActions(aArray) {
   gActionsQueue = new eventQueue();
 
   for (var idx = 0; idx < aArray.length; idx++) {
 
     var actionObj = aArray[idx];
     var accOrElmOrID = actionObj.ID;
     var actionIndex = actionObj.actionIndex;
     var actionName = actionObj.actionName;
@@ -89,86 +88,78 @@ function testActions(aArray)
   }
 
   gActionsQueue.invoke();
 }
 
 /**
  * Test action names and descriptions.
  */
-function testActionNames(aID, aActions)
-{
+function testActionNames(aID, aActions) {
   var actions = (typeof aActions == "string") ?
     [ aActions ] : (aActions || []);
 
   var acc = getAccessible(aID);
   is(acc.actionCount, actions.length, "Wong number of actions.");
   for (var i = 0; i < actions.length; i++ ) {
     is(acc.getActionName(i), actions[i], "Wrong action name at " + i + " index.");
     is(acc.getActionDescription(0), gActionDescrMap[actions[i]],
        "Wrong action description at " + i + "index.");
   }
 }
 
-////////////////////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////////////////
 // Private
 
 var gActionsQueue = null;
 
-function actionInvoker(aAccOrElmOrId, aActionIndex, aActionName, aEventSeq)
-{
-  this.invoke = function actionInvoker_i