--- a/addon-sdk/source/lib/sdk/content/l10n-html.js
+++ b/addon-sdk/source/lib/sdk/content/l10n-html.js
@@ -2,21 +2,25 @@
  * 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";
 
 module.metadata = {
   "stability": "unstable"
 };
 
-const { Ci } = require("chrome");
+const { Ci, Cc, Cu } = require("chrome");
 const core = require("../l10n/core");
 const { loadSheet, removeSheet } = require("../stylesheet/utils");
 const { process, frames } = require("../remote/child");
-const { Services } = require("resource://gre/modules/Services.jsm");
+var observerService = Cc["@mozilla.org/observer-service;1"]
+                      .getService(Ci.nsIObserverService);
+const { ShimWaiver } = Cu.import("resource://gre/modules/ShimWaiver.jsm");
+const addObserver = ShimWaiver.getProperty(observerService, "addObserver");
+const removeObserver = ShimWaiver.getProperty(observerService, "removeObserver");
 
 const assetsURI = require('../self').data.url();
 
 const hideSheetUri = "data:text/css,:root {visibility: hidden !important;}";
 
 function translateElementAttributes(element) {
   // Translateable attributes
   const attrList = ['title', 'accesskey', 'alt', 'label', 'placeholder'];
@@ -110,20 +114,20 @@ function onContentWindow(document) {
 
 // Listen to creation of content documents in order to translate them as soon
 // as possible in their loading process
 const ON_CONTENT = "document-element-inserted";
 let enabled = false;
 function enable() {
   if (enabled)
     return;
-  Services.obs.addObserver(onContentWindow, ON_CONTENT, false);
+  addObserver(onContentWindow, ON_CONTENT, false);
   enabled = true;
 }
 process.port.on("sdk/l10n/html/enable", enable);
 
 function disable() {
   if (!enabled)
     return;
-  Services.obs.removeObserver(onContentWindow, ON_CONTENT);
+  removeObserver(onContentWindow, ON_CONTENT);
   enabled = false;
 }
 process.port.on("sdk/l10n/html/disable", disable);

--- a/addon-sdk/source/lib/sdk/deprecated/window-utils.js
+++ b/addon-sdk/source/lib/sdk/deprecated/window-utils.js
@@ -57,17 +57,16 @@ function browserWindowIterator() {
 exports.browserWindowIterator = browserWindowIterator;
 
 function WindowTracker(delegate) {
    if (!(this instanceof WindowTracker)) {
      return new WindowTracker(delegate);
    }
 
   this._delegate = delegate;
-  this._loadingWindows = [];
 
   for (let window of getWindows())
     this._regWindow(window);
   windowWatcher.registerNotification(this);
   this._onToplevelWindowReady = this._onToplevelWindowReady.bind(this);
   events.on('toplevel-window-ready', this._onToplevelWindowReady);
 
   require('../system/unload').ensure(this);
@@ -76,27 +75,22 @@ function WindowTracker(delegate) {
 };
 
 WindowTracker.prototype = {
   _regLoadingWindow: function _regLoadingWindow(window) {
     // Bug 834961: ignore private windows when they are not supported
     if (ignoreWindow(window))
       return;
 
-    this._loadingWindows.push(window);
     window.addEventListener('load', this, true);
   },
 
   _unregLoadingWindow: function _unregLoadingWindow(window) {
-    var index = this._loadingWindows.indexOf(window);
-
-    if (index != -1) {
-      this._loadingWindows.splice(index, 1);
-      window.removeEventListener('load', this, true);
-    }
+    // This may have no effect if we ignored the window in _regLoadingWindow().
+    window.removeEventListener('load', this, true);
   },
 
   _regWindow: function _regWindow(window) {
     // Bug 834961: ignore private windows when they are not supported
     if (ignoreWindow(window))
       return;
 
     if (window.document.readyState == 'complete') {

--- a/browser/base/content/newtab/dropTargetShim.js
+++ b/browser/base/content/newtab/dropTargetShim.js
@@ -216,17 +216,17 @@ var gDropTargetShim = {
   /**
    * Dispatches a custom DragEvent on the given target node.
    * @param aEvent The source event.
    * @param aType The event type.
    * @param aTarget The target node that receives the event.
    */
   _dispatchEvent: function (aEvent, aType, aTarget) {
     let node = aTarget.node;
-    let event = document.createEvent("DragEvents");
+    let event = document.createEvent("DragEvent");
 
     // The event should not bubble to prevent recursion.
     event.initDragEvent(aType, false, true, window, 0, 0, 0, 0, 0, false, false,
                         false, false, 0, node, aEvent.dataTransfer);
 
     node.dispatchEvent(event);
   }
 };

--- a/browser/base/content/test/newtab/browser_newtab_bug723121.js
+++ b/browser/base/content/test/newtab/browser_newtab_bug723121.js
@@ -14,17 +14,17 @@ add_task(function* () {
     let link = site.querySelector(".newtab-link");
 
     function checkGridLocked(aLocked, aMessage) {
       Assert.equal(grid.node.hasAttribute("locked"), aLocked, aMessage);
     }
 
     function sendDragEvent(aEventType, aTarget) {
       let dataTransfer = new content.DataTransfer(aEventType, false);
-      let event = content.document.createEvent("DragEvents");
+      let event = content.document.createEvent("DragEvent");
       event.initDragEvent(aEventType, true, true, content, 0, 0, 0, 0, 0,
                           false, false, false, false, 0, null, dataTransfer);
       aTarget.dispatchEvent(event);
     }
 
     checkGridLocked(false, "grid is unlocked");
 
     sendDragEvent("dragstart", link);

--- a/browser/base/content/test/newtab/browser_newtab_bug725996.js
+++ b/browser/base/content/test/newtab/browser_newtab_bug725996.js
@@ -7,17 +7,17 @@ add_task(function* () {
 
   yield* addNewTabPageTab();
   yield* checkGrid("0,1,2,3,4,5,6,7,8");
 
   function doDrop(data) {
     return ContentTask.spawn(gBrowser.selectedBrowser, { data: data }, function*(args) {
       let dataTransfer = new content.DataTransfer("dragstart", false);
       dataTransfer.mozSetDataAt("text/x-moz-url", args.data, 0);
-      let event = content.document.createEvent("DragEvents");
+      let event = content.document.createEvent("DragEvent");
       event.initDragEvent("drop", true, true, content, 0, 0, 0, 0, 0,
                           false, false, false, false, 0, null, dataTransfer);
 
       let target = content.gGrid.cells[0].node;
       target.dispatchEvent(event);
     });
   }
 

--- a/browser/base/content/test/newtab/browser_newtab_bug765628.js
+++ b/browser/base/content/test/newtab/browser_newtab_bug765628.js
@@ -10,17 +10,17 @@ add_task(function* () {
 
   yield ContentTask.spawn(gBrowser.selectedBrowser, {}, function*() {
     const BAD_DRAG_DATA = "javascript:alert('h4ck0rz');\nbad stuff";
     const GOOD_DRAG_DATA = "http://example99.com/\nsite 99";
 
     function sendDropEvent(aCellIndex, aDragData) {
       let dataTransfer = new content.DataTransfer("dragstart", false);
       dataTransfer.mozSetDataAt("text/x-moz-url", aDragData, 0);
-      let event = content.document.createEvent("DragEvents");
+      let event = content.document.createEvent("DragEvent");
       event.initDragEvent("drop", true, true, content, 0, 0, 0, 0, 0,
                           false, false, false, false, 0, null, dataTransfer);
 
       let target = content.gGrid.cells[aCellIndex].node;
       target.dispatchEvent(event);
     }
 
     sendDropEvent(0, BAD_DRAG_DATA);

--- a/browser/base/content/test/newtab/browser_newtab_drag_drop.js
+++ b/browser/base/content/test/newtab/browser_newtab_drag_drop.js
@@ -73,23 +73,23 @@ add_task(function* () {
   yield doDragEvent(0, 4);
   yield* checkGrid("3,1p,2p,4,0p,5p,6,7,8");
 });
 
 function doDragEvent(sourceIndex, dropIndex) {
   return ContentTask.spawn(gBrowser.selectedBrowser,
                            { sourceIndex: sourceIndex, dropIndex: dropIndex }, function*(args) {
     let dataTransfer = new content.DataTransfer("dragstart", false);
-    let event = content.document.createEvent("DragEvents");
+    let event = content.document.createEvent("DragEvent");
     event.initDragEvent("dragstart", true, true, content, 0, 0, 0, 0, 0,
                         false, false, false, false, 0, null, dataTransfer);
 
     let target = content.gGrid.cells[args.sourceIndex].site.node;
     target.dispatchEvent(event);
 
-    event = content.document.createEvent("DragEvents");
+    event = content.document.createEvent("DragEvent");
     event.initDragEvent("drop", true, true, content, 0, 0, 0, 0, 0,
                         false, false, false, false, 0, null, dataTransfer);
 
     target = content.gGrid.cells[args.dropIndex].node;
     target.dispatchEvent(event);
   });
 }

--- a/browser/base/content/test/newtab/head.js
+++ b/browser/base/content/test/newtab/head.js
@@ -414,17 +414,17 @@ function* simulateExternalDrop(aDestInde
       let iframe = doc.createElement("iframe");
 
       function iframeLoaded() {
         let link = iframe.contentDocument.getElementById("link");
 
         let dataTransfer = new iframe.contentWindow.DataTransfer("dragstart", false);
         dataTransfer.mozSetDataAt("text/x-moz-url", "http://example99.com/", 0);
 
-        let event = content.document.createEvent("DragEvents");
+        let event = content.document.createEvent("DragEvent");
         event.initDragEvent("drop", true, true, content, 0, 0, 0, 0, 0,
                             false, false, false, false, 0, null, dataTransfer);
 
         let target = content.gGrid.cells[dropIndex].node;
         target.dispatchEvent(event);
 
         iframe.remove();
 

--- a/browser/components/extensions/schemas/tabs.json
+++ b/browser/components/extensions/schemas/tabs.json
@@ -829,17 +829,17 @@
             "name": "callback",
             "optional": true,
             "description": "Called after all the JavaScript has been executed.",
             "parameters": [
               {
                 "name": "result",
                 "optional": true,
                 "type": "array",
-                "items": {"type": "any", "minimum": 0},
+                "items": {"type": "any"},
                 "description": "The result of the script in every injected frame."
               }
             ]
           }
         ]
       },
       {
         "name": "insertCSS",

--- a/browser/components/nsBrowserGlue.js
+++ b/browser/components/nsBrowserGlue.js
@@ -2609,16 +2609,55 @@ ContentPermissionPrompt.prototype = {
     }
 
     secHistogram.add(Ci.nsISecurityUITelemetry.WARNING_GEOLOCATION_REQUEST);
 
     this._showPrompt(aRequest, message, "geo", actions, "geolocation",
                      "geo-notification-icon", options);
   },
 
+  _promptFlyWebPublishServer : function(aRequest) {
+    var message = "Would you like to let this site start a server accessible to nearby devices and people?";
+    var actions = [
+      {
+        stringId: "flyWebPublishServer.allowPublishServer",
+        action: Ci.nsIPermissionManager.ALLOW_ACTION,
+        expireType: Ci.nsIPermissionManager.EXPIRE_SESSION
+      },
+      {
+        stringId: "flyWebPublishServer.denyPublishServer",
+        action: Ci.nsIPermissionManager.DENY_ACTION,
+        expireType: Ci.nsIPermissionManager.EXPIRE_SESSION
+      }
+    ];
+
+    let options = {
+      learnMoreURL: "https://flyweb.github.io",
+      popupIconURL: "chrome://flyweb/skin/icon-64.png"
+    };
+
+    let browser = this._getBrowserForRequest(aRequest);
+    let chromeDoc = browser.ownerDocument;
+    let iconElem = chromeDoc.getElementById("flyweb-publish-server-notification-icon");
+    if (!iconElem) {
+      let notificationPopupBox = chromeDoc.getElementById("notification-popup-box");
+      let notificationIcon = chromeDoc.createElement("image");
+      notificationIcon.setAttribute("id", "flyweb-publish-server-notification-icon");
+      notificationIcon.setAttribute("src", "chrome://flyweb/skin/icon-64.png");
+      notificationIcon.setAttribute("class", "notification-anchor-icon flyweb-publish-server-icon");
+      notificationIcon.setAttribute("style", "filter: url(chrome://browser/skin/filters.svg#fill); fill: currentColor; opacity: .4;");
+      notificationIcon.setAttribute("role", "button");
+      notificationIcon.setAttribute("aria-label", "View the publish-server request");
+      notificationPopupBox.appendChild(notificationIcon);
+    }
+
+    this._showPrompt(aRequest, message, "flyweb-publish-server", actions, "flyweb-publish-server",
+                     "flyweb-publish-server-notification-icon", options);
+  },
+
   _promptWebNotifications : function(aRequest) {
     var message = gBrowserBundle.GetStringFromName("webNotifications.receiveFromSite");
 
     var actions;
 
     var browser = this._getBrowserForRequest(aRequest);
     // Only show "allow for session" in PB mode, we don't
     // support "allow for session" in non-PB mode.
@@ -2673,17 +2712,18 @@ ContentPermissionPrompt.prototype = {
     let types = request.types.QueryInterface(Ci.nsIArray);
     if (types.length != 1) {
       request.cancel();
       return;
     }
     let perm = types.queryElementAt(0, Ci.nsIContentPermissionType);
 
     const kFeatureKeys = { "geolocation" : "geo",
-                           "desktop-notification" : "desktop-notification"
+                           "desktop-notification" : "desktop-notification",
+                           "flyweb-publish-server": "flyweb-publish-server"
                          };
 
     // Make sure that we support the request.
     if (!(perm.type in kFeatureKeys)) {
       return;
     }
 
     var requestingPrincipal = request.principal;
@@ -2716,16 +2756,21 @@ ContentPermissionPrompt.prototype = {
     // Show the prompt.
     switch (perm.type) {
     case "geolocation":
       this._promptGeo(request);
       break;
     case "desktop-notification":
       this._promptWebNotifications(request);
       break;
+    case "flyweb-publish-server":
+      if (AppConstants.NIGHTLY_BUILD) {
+        this._promptFlyWebPublishServer(request);
+      }
+      break;
     }
   },
 
 };
 
 var DefaultBrowserCheck = {
   get OPTIONPOPUP() { return "defaultBrowserNotificationPopup" },
   _setAsDefaultTimer: null,

--- a/browser/extensions/e10srollout/bootstrap.js
+++ b/browser/extensions/e10srollout/bootstrap.js
@@ -8,16 +8,17 @@ const {classes: Cc, interfaces: Ci, util
 
 Cu.import("resource://gre/modules/Preferences.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/UpdateUtils.jsm");
 
  // The amount of people to be part of e10s
 const TEST_THRESHOLD = {
   "beta"    : 0.5,  // 50%
+  "release" : 1.0,  // 100%
 };
 
 const ADDON_ROLLOUT_POLICY = {
   "beta"    : "2a", // Set 2 + any WebExtension
 };
 
 const PREF_COHORT_SAMPLE       = "e10s.rollout.cohortSample";
 const PREF_COHORT_NAME         = "e10s.rollout.cohort";

--- a/browser/extensions/e10srollout/install.rdf.in
+++ b/browser/extensions/e10srollout/install.rdf.in
@@ -5,17 +5,17 @@
 
 #filter substitution
 
 <RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
      xmlns:em="http://www.mozilla.org/2004/em-rdf#">
 
   <Description about="urn:mozilla:install-manifest">
     <em:id>e10srollout@mozilla.org</em:id>
-    <em:version>1.0</em:version>
+    <em:version>1.2</em:version>
     <em:type>2</em:type>
     <em:bootstrap>true</em:bootstrap>
     <em:multiprocessCompatible>true</em:multiprocessCompatible>
 
     <!-- Target Application this theme can install into,
         with minimum and maximum supported versions. -->
     <em:targetApplication>
       <Description>

--- a/browser/locales/en-US/chrome/browser/browser.properties
+++ b/browser/locales/en-US/chrome/browser/browser.properties
@@ -373,16 +373,26 @@ geolocation.shareLocation=Share Location
 geolocation.shareLocation.accesskey=a
 geolocation.alwaysShareLocation=Always Share Location
 geolocation.alwaysShareLocation.accesskey=A
 geolocation.neverShareLocation=Never Share Location
 geolocation.neverShareLocation.accesskey=N
 geolocation.shareWithSite2=Would you like to share your location with this site?
 geolocation.shareWithFile2=Would you like to share your location with this file?
 
+# FlyWeb UI
+# LOCALIZATION NOTE (flyWebPublishServer.allowPublishServer): This is an experimental feature only shipping in Nightly, and doesn't need translation.
+flyWebPublishServer.allowPublishServer=Allow Server
+# LOCALIZATION NOTE (flyWebPublishServer.allowPublishServer.accessKey): This is an experimental feature only shipping in Nightly, and doesn't need translation.
+flyWebPublishServer.allowPublishServer.accesskey=A
+# LOCALIZATION NOTE (flyWebPublishServer.denyPublishServer): This is an experimental feature only shipping in Nightly, and doesn't need translation.
+flyWebPublishServer.denyPublishServer=Block Server
+# LOCALIZATION NOTE (flyWebPublishServer.denyPublishServer.accessKey): This is an experimental feature only shipping in Nightly, and doesn't need translation.
+flyWebPublishServer.denyPublishServer.accesskey=B
+
 webNotifications.receiveForSession=Receive for this session
 webNotifications.receiveForSession.accesskey=s
 webNotifications.alwaysReceive=Always Receive Notifications
 webNotifications.alwaysReceive.accesskey=A
 webNotifications.neverShow=Always Block Notifications
 webNotifications.neverShow.accesskey=N
 webNotifications.receiveFromSite=Would you like to receive notifications from this site?
 # LOCALIZATION NOTE (webNotifications.upgradeTitle): When using native notifications on OS X, the title may be truncated around 32 characters.

--- a/browser/themes/shared/devedition.inc.css
+++ b/browser/themes/shared/devedition.inc.css
@@ -53,20 +53,16 @@
   --urlbar-dropmarker-hover-region: rect(0, 22px, 14px, 11px);
   --urlbar-dropmarker-active-region: rect(0px, 33px, 14px, 22px);
   --urlbar-dropmarker-2x-url: url("chrome://browser/skin/devedition/urlbar-history-dropmarker.svg");
   --urlbar-dropmarker-2x-region: rect(0px, 11px, 14px, 0px);
   --urlbar-dropmarker-hover-2x-region: rect(0, 22px, 14px, 11px);
   --urlbar-dropmarker-active-2x-region: rect(0px, 33px, 14px, 22px);
 }
 
-:root[devtoolstheme="dark"] #identity-box {
-  --identity-box-chrome-color: #46afe3;
-}
-
 :root[devtoolstheme="light"] {
   --url-and-searchbar-background-color: #fff;
 
   --chrome-background-color: #E3E4E6;
   --chrome-color: #18191a;
   --chrome-secondary-background-color: #f5f6f7;
   --chrome-navigator-toolbox-separator-color: #cccccc;
   --chrome-nav-bar-separator-color: #B6B6B8;

--- a/browser/themes/shared/identity-block/identity-block.inc.css
+++ b/browser/themes/shared/identity-block/identity-block.inc.css
@@ -1,42 +1,33 @@
 %if 0
 /* 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/. */
 %endif
 
 #identity-box {
-  --identity-box-verified-color: hsl(92,100%,30%);
-%ifdef MOZ_OFFICIAL_BRANDING
-  --identity-box-chrome-color: rgb(229,115,0);
-%else
-%if MOZ_UPDATE_CHANNEL == aurora
-  --identity-box-chrome-color: rgb(51,30,84);
-%else
-  --identity-box-chrome-color: rgb(0,33,71);
-%endif
-%endif
-
   font-size: .9em;
   padding: 3px 5px;
   overflow: hidden;
   /* The padding-left and padding-right transitions handle the delayed hiding of
      the forward button when hovered. */
   transition: padding-left, padding-right;
 }
 
-#urlbar[pageproxystate="valid"] > #identity-box.verifiedIdentity > #connection-icon,
 #urlbar[pageproxystate="valid"] > #identity-box.verifiedIdentity > #identity-icon-labels {
-  color: var(--identity-box-verified-color);
+  color: hsl(92,100%,30%);
 }
 
-#urlbar[pageproxystate="valid"] > #identity-box.chromeUI > #connection-icon,
 #urlbar[pageproxystate="valid"] > #identity-box.chromeUI > #identity-icon-labels {
-  color: var(--identity-box-chrome-color);
+%ifdef MOZ_OFFICIAL_BRANDING
+  color: rgb(229,115,0);
+%else
+  color: inherit;
+%endif
 }
 
 #identity-icon-labels:-moz-locale-dir(ltr) {
   padding-left: 2px;
 }
 
 #identity-icon-labels:-moz-locale-dir(rtl) {
   padding-right: 2px;

--- a/build/clang-plugin/clang-plugin.cpp
+++ b/build/clang-plugin/clang-plugin.cpp
@@ -1,12 +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/. */
 
+/* This file respects the LLVM coding standard described at
+ * http://llvm.org/docs/CodingStandards.html */
+
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Basic/Version.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendPluginRegistry.h"
@@ -37,47 +40,47 @@ typedef ASTConsumer *ASTConsumerPtr;
 #define cxxMethodDecl methodDecl
 #define cxxNewExpr newExpr
 #define cxxRecordDecl recordDecl
 #endif
 
 // Check if the given expression contains an assignment expression.
 // This can either take the form of a Binary Operator or a
 // Overloaded Operator Call.
-bool HasSideEffectAssignment(const Expr *expr) {
-  if (auto opCallExpr = dyn_cast_or_null<CXXOperatorCallExpr>(expr)) {
-    auto binOp = opCallExpr->getOperator();
-    if (binOp == OO_Equal || (binOp >= OO_PlusEqual && binOp <= OO_PipeEqual)) {
+bool hasSideEffectAssignment(const Expr *Expression) {
+  if (auto OpCallExpr = dyn_cast_or_null<CXXOperatorCallExpr>(Expression)) {
+    auto BinOp = OpCallExpr->getOperator();
+    if (BinOp == OO_Equal || (BinOp >= OO_PlusEqual && BinOp <= OO_PipeEqual)) {
       return true;
     }
-  } else if (auto binOpExpr = dyn_cast_or_null<BinaryOperator>(expr)) {
-    if (binOpExpr->isAssignmentOp()) {
+  } else if (auto BinOpExpr = dyn_cast_or_null<BinaryOperator>(Expression)) {
+    if (BinOpExpr->isAssignmentOp()) {
       return true;
     }
   }
 
   // Recurse to children.
-  for (const Stmt *SubStmt : expr->children()) {
-    auto childExpr = dyn_cast_or_null<Expr>(SubStmt);
-    if (childExpr && HasSideEffectAssignment(childExpr)) {
+  for (const Stmt *SubStmt : Expression->children()) {
+    auto ChildExpr = dyn_cast_or_null<Expr>(SubStmt);
+    if (ChildExpr && hasSideEffectAssignment(ChildExpr)) {
       return true;
     }
   }
 
   return false;
 }
 
 namespace {
 
 using namespace clang::ast_matchers;
 class DiagnosticsMatcher {
 public:
   DiagnosticsMatcher();
 
-  ASTConsumerPtr makeASTConsumer() { return astMatcher.newASTConsumer(); }
+  ASTConsumerPtr makeASTConsumer() { return AstMatcher.newASTConsumer(); }
 
 private:
   class ScopeChecker : public MatchFinder::MatchCallback {
   public:
     virtual void run(const MatchFinder::MatchResult &Result);
   };
 
   class ArithmeticArgChecker : public MatchFinder::MatchCallback {
@@ -150,134 +153,134 @@ private:
     virtual void run(const MatchFinder::MatchResult &Result);
   };
 
   class AssertAssignmentChecker : public MatchFinder::MatchCallback {
   public:
     virtual void run(const MatchFinder::MatchResult &Result);
   };
 
-  ScopeChecker scopeChecker;
-  ArithmeticArgChecker arithmeticArgChecker;
-  TrivialCtorDtorChecker trivialCtorDtorChecker;
-  NaNExprChecker nanExprChecker;
-  NoAddRefReleaseOnReturnChecker noAddRefReleaseOnReturnChecker;
-  RefCountedInsideLambdaChecker refCountedInsideLambdaChecker;
-  ExplicitOperatorBoolChecker explicitOperatorBoolChecker;
-  NoDuplicateRefCntMemberChecker noDuplicateRefCntMemberChecker;
-  NeedsNoVTableTypeChecker needsNoVTableTypeChecker;
-  NonMemMovableTemplateArgChecker nonMemMovableTemplateArgChecker;
-  NonMemMovableMemberChecker nonMemMovableMemberChecker;
-  ExplicitImplicitChecker explicitImplicitChecker;
-  NoAutoTypeChecker noAutoTypeChecker;
-  NoExplicitMoveConstructorChecker noExplicitMoveConstructorChecker;
-  RefCountedCopyConstructorChecker refCountedCopyConstructorChecker;
-  AssertAssignmentChecker assertAttributionChecker;
-  MatchFinder astMatcher;
+  ScopeChecker Scope;
+  ArithmeticArgChecker ArithmeticArg;
+  TrivialCtorDtorChecker TrivialCtorDtor;
+  NaNExprChecker NaNExpr;
+  NoAddRefReleaseOnReturnChecker NoAddRefReleaseOnReturn;
+  RefCountedInsideLambdaChecker RefCountedInsideLambda;
+  ExplicitOperatorBoolChecker ExplicitOperatorBool;
+  NoDuplicateRefCntMemberChecker NoDuplicateRefCntMember;
+  NeedsNoVTableTypeChecker NeedsNoVTableType;
+  NonMemMovableTemplateArgChecker NonMemMovableTemplateArg;
+  NonMemMovableMemberChecker NonMemMovableMember;
+  ExplicitImplicitChecker ExplicitImplicit;
+  NoAutoTypeChecker NoAutoType;
+  NoExplicitMoveConstructorChecker NoExplicitMoveConstructor;
+  RefCountedCopyConstructorChecker RefCountedCopyConstructor;
+  AssertAssignmentChecker AssertAttribution;
+  MatchFinder AstMatcher;
 };
 
 namespace {
 
-std::string getDeclarationNamespace(const Decl *decl) {
+std::string getDeclarationNamespace(const Decl *Declaration) {
   const DeclContext *DC =
-      decl->getDeclContext()->getEnclosingNamespaceContext();
+      Declaration->getDeclContext()->getEnclosingNamespaceContext();
   const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC);
   if (!ND) {
     return "";
   }
 
   while (const DeclContext *ParentDC = ND->getParent()) {
     if (!isa<NamespaceDecl>(ParentDC)) {
       break;
     }
     ND = cast<NamespaceDecl>(ParentDC);
   }
 
-  const auto &name = ND->getName();
-  return name;
+  const auto &Name = ND->getName();
+  return Name;
 }
 
-bool isInIgnoredNamespaceForImplicitCtor(const Decl *decl) {
-  std::string name = getDeclarationNamespace(decl);
-  if (name == "") {
+bool isInIgnoredNamespaceForImplicitCtor(const Decl *Declaration) {
+  std::string Name = getDeclarationNamespace(Declaration);
+  if (Name == "") {
     return false;
   }
 
-  return name == "std" ||               // standard C++ lib
-         name == "__gnu_cxx" ||         // gnu C++ lib
-         name == "boost" ||             // boost
-         name == "webrtc" ||            // upstream webrtc
-         name == "rtc" ||               // upstream webrtc 'base' package
-         name.substr(0, 4) == "icu_" || // icu
-         name == "google" ||            // protobuf
-         name == "google_breakpad" ||   // breakpad
-         name == "soundtouch" ||        // libsoundtouch
-         name == "stagefright" ||       // libstagefright
-         name == "MacFileUtilities" ||  // MacFileUtilities
-         name == "dwarf2reader" ||      // dwarf2reader
-         name == "arm_ex_to_module" ||  // arm_ex_to_module
-         name == "testing";             // gtest
+  return Name == "std" ||               // standard C++ lib
+         Name == "__gnu_cxx" ||         // gnu C++ lib
+         Name == "boost" ||             // boost
+         Name == "webrtc" ||            // upstream webrtc
+         Name == "rtc" ||               // upstream webrtc 'base' package
+         Name.substr(0, 4) == "icu_" || // icu
+         Name == "google" ||            // protobuf
+         Name == "google_breakpad" ||   // breakpad
+         Name == "soundtouch" ||        // libsoundtouch
+         Name == "stagefright" ||       // libstagefright
+         Name == "MacFileUtilities" ||  // MacFileUtilities
+         Name == "dwarf2reader" ||      // dwarf2reader
+         Name == "arm_ex_to_module" ||  // arm_ex_to_module
+         Name == "testing";             // gtest
 }
 
-bool isInIgnoredNamespaceForImplicitConversion(const Decl *decl) {
-  std::string name = getDeclarationNamespace(decl);
-  if (name == "") {
+bool isInIgnoredNamespaceForImplicitConversion(const Decl *Declaration) {
+  std::string Name = getDeclarationNamespace(Declaration);
+  if (Name == "") {
     return false;
   }
 
-  return name == "std" ||             // standard C++ lib
-         name == "__gnu_cxx" ||       // gnu C++ lib
-         name == "google_breakpad" || // breakpad
-         name == "testing";           // gtest
+  return Name == "std" ||             // standard C++ lib
+         Name == "__gnu_cxx" ||       // gnu C++ lib
+         Name == "google_breakpad" || // breakpad
+         Name == "testing";           // gtest
 }
 
-bool isIgnoredPathForImplicitCtor(const Decl *decl) {
-  SourceLocation Loc = decl->getLocation();
-  const SourceManager &SM = decl->getASTContext().getSourceManager();
+bool isIgnoredPathForImplicitCtor(const Decl *Declaration) {
+  SourceLocation Loc = Declaration->getLocation();
+  const SourceManager &SM = Declaration->getASTContext().getSourceManager();
   SmallString<1024> FileName = SM.getFilename(Loc);
   llvm::sys::fs::make_absolute(FileName);
-  llvm::sys::path::reverse_iterator begin = llvm::sys::path::rbegin(FileName),
-                                    end = llvm::sys::path::rend(FileName);
-  for (; begin != end; ++begin) {
-    if (begin->compare_lower(StringRef("skia")) == 0 ||
-        begin->compare_lower(StringRef("angle")) == 0 ||
-        begin->compare_lower(StringRef("harfbuzz")) == 0 ||
-        begin->compare_lower(StringRef("hunspell")) == 0 ||
-        begin->compare_lower(StringRef("scoped_ptr.h")) == 0 ||
-        begin->compare_lower(StringRef("graphite2")) == 0) {
+  llvm::sys::path::reverse_iterator Begin = llvm::sys::path::rbegin(FileName),
+                                    End = llvm::sys::path::rend(FileName);
+  for (; Begin != End; ++Begin) {
+    if (Begin->compare_lower(StringRef("skia")) == 0 ||
+        Begin->compare_lower(StringRef("angle")) == 0 ||
+        Begin->compare_lower(StringRef("harfbuzz")) == 0 ||
+        Begin->compare_lower(StringRef("hunspell")) == 0 ||
+        Begin->compare_lower(StringRef("scoped_ptr.h")) == 0 ||
+        Begin->compare_lower(StringRef("graphite2")) == 0) {
       return true;
     }
-    if (begin->compare_lower(StringRef("chromium")) == 0) {
+    if (Begin->compare_lower(StringRef("chromium")) == 0) {
       // Ignore security/sandbox/chromium but not ipc/chromium.
-      ++begin;
-      return begin != end && begin->compare_lower(StringRef("sandbox")) == 0;
+      ++Begin;
+      return Begin != End && Begin->compare_lower(StringRef("sandbox")) == 0;
     }
   }
   return false;
 }
 
-bool isIgnoredPathForImplicitConversion(const Decl *decl) {
-  decl = decl->getCanonicalDecl();
-  SourceLocation Loc = decl->getLocation();
-  const SourceManager &SM = decl->getASTContext().getSourceManager();
+bool isIgnoredPathForImplicitConversion(const Decl *Declaration) {
+  Declaration = Declaration->getCanonicalDecl();
+  SourceLocation Loc = Declaration->getLocation();
+  const SourceManager &SM = Declaration->getASTContext().getSourceManager();
   SmallString<1024> FileName = SM.getFilename(Loc);
   llvm::sys::fs::make_absolute(FileName);
-  llvm::sys::path::reverse_iterator begin = llvm::sys::path::rbegin(FileName),
-                                    end = llvm::sys::path::rend(FileName);
-  for (; begin != end; ++begin) {
-    if (begin->compare_lower(StringRef("graphite2")) == 0) {
+  llvm::sys::path::reverse_iterator Begin = llvm::sys::path::rbegin(FileName),
+                                    End = llvm::sys::path::rend(FileName);
+  for (; Begin != End; ++Begin) {
+    if (Begin->compare_lower(StringRef("graphite2")) == 0) {
       return true;
     }
   }
   return false;
 }
 
-bool isInterestingDeclForImplicitConversion(const Decl *decl) {
-  return !isInIgnoredNamespaceForImplicitConversion(decl) &&
-         !isIgnoredPathForImplicitConversion(decl);
+bool isInterestingDeclForImplicitConversion(const Decl *Declaration) {
+  return !isInIgnoredNamespaceForImplicitConversion(Declaration) &&
+         !isIgnoredPathForImplicitConversion(Declaration);
 }
 
 bool isIgnoredExprForMustUse(const Expr *E) {
   if (const CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(E)) {
     switch (OpCall->getOperator()) {
     case OO_Equal:
     case OO_PlusEqual:
     case OO_MinusEqual:
@@ -400,257 +403,257 @@ protected:
   }
 };
 
 static MemMoveAnnotation NonMemMovable = MemMoveAnnotation();
 
 class MozChecker : public ASTConsumer, public RecursiveASTVisitor<MozChecker> {
   DiagnosticsEngine &Diag;
   const CompilerInstance &CI;
-  DiagnosticsMatcher matcher;
+  DiagnosticsMatcher Matcher;
 
 public:
   MozChecker(const CompilerInstance &CI) : Diag(CI.getDiagnostics()), CI(CI) {}
 
-  ASTConsumerPtr getOtherConsumer() { return matcher.makeASTConsumer(); }
+  ASTConsumerPtr getOtherConsumer() { return Matcher.makeASTConsumer(); }
 
-  virtual void HandleTranslationUnit(ASTContext &ctx) {
-    TraverseDecl(ctx.getTranslationUnitDecl());
+  virtual void HandleTranslationUnit(ASTContext &Ctx) override {
+    TraverseDecl(Ctx.getTranslationUnitDecl());
   }
 
   static bool hasCustomAnnotation(const Decl *D, const char *Spelling) {
     iterator_range<specific_attr_iterator<AnnotateAttr>> Attrs =
         D->specific_attrs<AnnotateAttr>();
 
     for (AnnotateAttr *Attr : Attrs) {
       if (Attr->getAnnotation() == Spelling) {
         return true;
       }
     }
 
     return false;
   }
 
-  void HandleUnusedExprResult(const Stmt *stmt) {
-    const Expr *E = dyn_cast_or_null<Expr>(stmt);
+  void handleUnusedExprResult(const Stmt *Statement) {
+    const Expr *E = dyn_cast_or_null<Expr>(Statement);
     if (E) {
       E = E->IgnoreImplicit(); // Ignore ExprWithCleanup etc. implicit wrappers
       QualType T = E->getType();
       if (MustUse.hasEffectiveAnnotation(T) && !isIgnoredExprForMustUse(E)) {
-        unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+        unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
             DiagnosticIDs::Error, "Unused value of must-use type %0");
 
-        Diag.Report(E->getLocStart(), errorID) << T;
+        Diag.Report(E->getLocStart(), ErrorID) << T;
         MustUse.dumpAnnotationReason(Diag, T, E->getLocStart());
       }
     }
   }
 
-  bool VisitCXXRecordDecl(CXXRecordDecl *d) {
+  bool VisitCXXRecordDecl(CXXRecordDecl *D) {
     // We need definitions, not declarations
-    if (!d->isThisDeclarationADefinition())
+    if (!D->isThisDeclarationADefinition())
       return true;
 
     // Look through all of our immediate bases to find methods that need to be
     // overridden
     typedef std::vector<CXXMethodDecl *> OverridesVector;
-    OverridesVector must_overrides;
-    for (CXXRecordDecl::base_class_iterator base = d->bases_begin(),
-                                            e = d->bases_end();
-         base != e; ++base) {
+    OverridesVector MustOverrides;
+    for (CXXRecordDecl::base_class_iterator Base = D->bases_begin(),
+                                            E = D->bases_end();
+         Base != E; ++Base) {
       // The base is either a class (CXXRecordDecl) or it's a templated class...
-      CXXRecordDecl *parent = base->getType()
-                                  .getDesugaredType(d->getASTContext())
+      CXXRecordDecl *Parent = Base->getType()
+                                  .getDesugaredType(D->getASTContext())
                                   ->getAsCXXRecordDecl();
       // The parent might not be resolved to a type yet. In this case, we can't
       // do any checking here. For complete correctness, we should visit
       // template instantiations, but this case is likely to be rare, so we will
       // ignore it until it becomes important.
-      if (!parent) {
+      if (!Parent) {
         continue;
       }
-      parent = parent->getDefinition();
-      for (CXXRecordDecl::method_iterator M = parent->method_begin();
-           M != parent->method_end(); ++M) {
+      Parent = Parent->getDefinition();
+      for (CXXRecordDecl::method_iterator M = Parent->method_begin();
+           M != Parent->method_end(); ++M) {
         if (hasCustomAnnotation(*M, "moz_must_override"))
-          must_overrides.push_back(*M);
+          MustOverrides.push_back(*M);
       }
     }
 
-    for (OverridesVector::iterator it = must_overrides.begin();
-         it != must_overrides.end(); ++it) {
-      bool overridden = false;
-      for (CXXRecordDecl::method_iterator M = d->method_begin();
-           !overridden && M != d->method_end(); ++M) {
+    for (OverridesVector::iterator It = MustOverrides.begin();
+         It != MustOverrides.end(); ++It) {
+      bool Overridden = false;
+      for (CXXRecordDecl::method_iterator M = D->method_begin();
+           !Overridden && M != D->method_end(); ++M) {
         // The way that Clang checks if a method M overrides its parent method
         // is if the method has the same name but would not overload.
-        if (getNameChecked(M) == getNameChecked(*it) &&
-            !CI.getSema().IsOverload(*M, (*it), false)) {
-          overridden = true;
+        if (getNameChecked(M) == getNameChecked(*It) &&
+            !CI.getSema().IsOverload(*M, (*It), false)) {
+          Overridden = true;
           break;
         }
       }
-      if (!overridden) {
-        unsigned overrideID = Diag.getDiagnosticIDs()->getCustomDiagID(
+      if (!Overridden) {
+        unsigned OverrideID = Diag.getDiagnosticIDs()->getCustomDiagID(
             DiagnosticIDs::Error, "%0 must override %1");
-        unsigned overrideNote = Diag.getDiagnosticIDs()->getCustomDiagID(
+        unsigned OverrideNote = Diag.getDiagnosticIDs()->getCustomDiagID(
             DiagnosticIDs::Note, "function to override is here");
-        Diag.Report(d->getLocation(), overrideID) << d->getDeclName()
-                                                  << (*it)->getDeclName();
-        Diag.Report((*it)->getLocation(), overrideNote);
+        Diag.Report(D->getLocation(), OverrideID) << D->getDeclName()
+                                                  << (*It)->getDeclName();
+        Diag.Report((*It)->getLocation(), OverrideNote);
       }
     }
 
     return true;
   }
 
-  bool VisitSwitchCase(SwitchCase *stmt) {
-    HandleUnusedExprResult(stmt->getSubStmt());
+  bool VisitSwitchCase(SwitchCase *Statement) {
+    handleUnusedExprResult(Statement->getSubStmt());
     return true;
   }
-  bool VisitCompoundStmt(CompoundStmt *stmt) {
-    for (CompoundStmt::body_iterator it = stmt->body_begin(),
-                                     e = stmt->body_end();
-         it != e; ++it) {
-      HandleUnusedExprResult(*it);
+  bool VisitCompoundStmt(CompoundStmt *Statement) {
+    for (CompoundStmt::body_iterator It = Statement->body_begin(),
+                                     E = Statement->body_end();
+         It != E; ++It) {
+      handleUnusedExprResult(*It);
     }
     return true;
   }
-  bool VisitIfStmt(IfStmt *Stmt) {
-    HandleUnusedExprResult(Stmt->getThen());
-    HandleUnusedExprResult(Stmt->getElse());
+  bool VisitIfStmt(IfStmt *Statement) {
+    handleUnusedExprResult(Statement->getThen());
+    handleUnusedExprResult(Statement->getElse());
     return true;
   }
-  bool VisitWhileStmt(WhileStmt *Stmt) {
-    HandleUnusedExprResult(Stmt->getBody());
+  bool VisitWhileStmt(WhileStmt *Statement) {
+    handleUnusedExprResult(Statement->getBody());
     return true;
   }
-  bool VisitDoStmt(DoStmt *Stmt) {
-    HandleUnusedExprResult(Stmt->getBody());
+  bool VisitDoStmt(DoStmt *Statement) {
+    handleUnusedExprResult(Statement->getBody());
     return true;
   }
-  bool VisitForStmt(ForStmt *Stmt) {
-    HandleUnusedExprResult(Stmt->getBody());
-    HandleUnusedExprResult(Stmt->getInit());
-    HandleUnusedExprResult(Stmt->getInc());
+  bool VisitForStmt(ForStmt *Statement) {
+    handleUnusedExprResult(Statement->getBody());
+    handleUnusedExprResult(Statement->getInit());
+    handleUnusedExprResult(Statement->getInc());
     return true;
   }
   bool VisitBinComma(BinaryOperator *Op) {
-    HandleUnusedExprResult(Op->getLHS());
+    handleUnusedExprResult(Op->getLHS());
     return true;
   }
 };
 
 /// A cached data of whether classes are refcounted or not.
 typedef DenseMap<const CXXRecordDecl *, std::pair<const Decl *, bool>>
     RefCountedMap;
-RefCountedMap refCountedClasses;
+RefCountedMap RefCountedClasses;
 
 bool classHasAddRefRelease(const CXXRecordDecl *D) {
-  const RefCountedMap::iterator &it = refCountedClasses.find(D);
-  if (it != refCountedClasses.end()) {
-    return it->second.second;
+  const RefCountedMap::iterator &It = RefCountedClasses.find(D);
+  if (It != RefCountedClasses.end()) {
+    return It->second.second;
   }
 
-  bool seenAddRef = false;
-  bool seenRelease = false;
-  for (CXXRecordDecl::method_iterator method = D->method_begin();
-       method != D->method_end(); ++method) {
-    const auto &name = getNameChecked(method);
-    if (name == "AddRef") {
-      seenAddRef = true;
-    } else if (name == "Release") {
-      seenRelease = true;
+  bool SeenAddRef = false;
+  bool SeenRelease = false;
+  for (CXXRecordDecl::method_iterator Method = D->method_begin();
+       Method != D->method_end(); ++Method) {
+    const auto &Name = getNameChecked(Method);
+    if (Name == "AddRef") {
+      SeenAddRef = true;
+    } else if (Name == "Release") {
+      SeenRelease = true;
     }
   }
-  refCountedClasses[D] = std::make_pair(D, seenAddRef && seenRelease);
-  return seenAddRef && seenRelease;
+  RefCountedClasses[D] = std::make_pair(D, SeenAddRef && SeenRelease);
+  return SeenAddRef && SeenRelease;
 }
 
 bool isClassRefCounted(QualType T);
 
 bool isClassRefCounted(const CXXRecordDecl *D) {
   // Normalize so that D points to the definition if it exists.
   if (!D->hasDefinition())
     return false;
   D = D->getDefinition();
   // Base class: anyone with AddRef/Release is obviously a refcounted class.
   if (classHasAddRefRelease(D))
     return true;
 
   // Look through all base cases to figure out if the parent is a refcounted
   // class.
-  for (CXXRecordDecl::base_class_const_iterator base = D->bases_begin();
-       base != D->bases_end(); ++base) {
-    bool super = isClassRefCounted(base->getType());
-    if (super) {
+  for (CXXRecordDecl::base_class_const_iterator Base = D->bases_begin();
+       Base != D->bases_end(); ++Base) {
+    bool Super = isClassRefCounted(Base->getType());
+    if (Super) {
       return true;
     }
   }
 
   return false;
 }
 
 bool isClassRefCounted(QualType T) {
-  while (const clang::ArrayType *arrTy = T->getAsArrayTypeUnsafe())
-    T = arrTy->getElementType();
-  CXXRecordDecl *clazz = T->getAsCXXRecordDecl();
-  return clazz ? isClassRefCounted(clazz) : false;
+  while (const clang::ArrayType *ArrTy = T->getAsArrayTypeUnsafe())
+    T = ArrTy->getElementType();
+  CXXRecordDecl *Clazz = T->getAsCXXRecordDecl();
+  return Clazz ? isClassRefCounted(Clazz) : false;
 }
 
-template <class T> bool IsInSystemHeader(const ASTContext &AC, const T &D) {
+template <class T> bool ASTIsInSystemHeader(const ASTContext &AC, const T &D) {
   auto &SourceManager = AC.getSourceManager();
   auto ExpansionLoc = SourceManager.getExpansionLoc(D.getLocStart());
   if (ExpansionLoc.isInvalid()) {
     return false;
   }
   return SourceManager.isInSystemHeader(ExpansionLoc);
 }
 
 const FieldDecl *getClassRefCntMember(const CXXRecordDecl *D) {
-  for (RecordDecl::field_iterator field = D->field_begin(), e = D->field_end();
-       field != e; ++field) {
-    if (getNameChecked(field) == "mRefCnt") {
-      return *field;
+  for (RecordDecl::field_iterator Field = D->field_begin(), E = D->field_end();
+       Field != E; ++Field) {
+    if (getNameChecked(Field) == "mRefCnt") {
+      return *Field;
     }
   }
   return 0;
 }
 
 const FieldDecl *getBaseRefCntMember(QualType T);
 
 const FieldDecl *getBaseRefCntMember(const CXXRecordDecl *D) {
-  const FieldDecl *refCntMember = getClassRefCntMember(D);
-  if (refCntMember && isClassRefCounted(D)) {
-    return refCntMember;
+  const FieldDecl *RefCntMember = getClassRefCntMember(D);
+  if (RefCntMember && isClassRefCounted(D)) {
+    return RefCntMember;
   }
 
-  for (CXXRecordDecl::base_class_const_iterator base = D->bases_begin(),
-                                                e = D->bases_end();
-       base != e; ++base) {
-    refCntMember = getBaseRefCntMember(base->getType());
-    if (refCntMember) {
-      return refCntMember;
+  for (CXXRecordDecl::base_class_const_iterator Base = D->bases_begin(),
+                                                E = D->bases_end();
+       Base != E; ++Base) {
+    RefCntMember = getBaseRefCntMember(Base->getType());
+    if (RefCntMember) {
+      return RefCntMember;
     }
   }
   return 0;
 }
 
 const FieldDecl *getBaseRefCntMember(QualType T) {
-  while (const clang::ArrayType *arrTy = T->getAsArrayTypeUnsafe())
-    T = arrTy->getElementType();
-  CXXRecordDecl *clazz = T->getAsCXXRecordDecl();
-  return clazz ? getBaseRefCntMember(clazz) : 0;
+  while (const clang::ArrayType *ArrTy = T->getAsArrayTypeUnsafe())
+    T = ArrTy->getElementType();
+  CXXRecordDecl *Clazz = T->getAsCXXRecordDecl();
+  return Clazz ? getBaseRefCntMember(Clazz) : 0;
 }
 
 bool typeHasVTable(QualType T) {
-  while (const clang::ArrayType *arrTy = T->getAsArrayTypeUnsafe())
-    T = arrTy->getElementType();
-  CXXRecordDecl *offender = T->getAsCXXRecordDecl();
-  return offender && offender->hasDefinition() && offender->isDynamicClass();
+  while (const clang::ArrayType *ArrTy = T->getAsArrayTypeUnsafe())
+    T = ArrTy->getElementType();
+  CXXRecordDecl *Offender = T->getAsCXXRecordDecl();
+  return Offender && Offender->hasDefinition() && Offender->isDynamicClass();
 }
 }
 
 namespace clang {
 namespace ast_matchers {
 
 /// This matcher will match any function declaration that is declared as a heap
 /// allocator.
@@ -674,49 +677,49 @@ AST_MATCHER(CXXRecordDecl, hasTrivialCto
 /// calling AddRef or Release on its return value.
 AST_MATCHER(FunctionDecl, hasNoAddRefReleaseOnReturnAttr) {
   return MozChecker::hasCustomAnnotation(&Node,
                                          "moz_no_addref_release_on_return");
 }
 
 /// This matcher will match all arithmetic binary operators.
 AST_MATCHER(BinaryOperator, binaryArithmeticOperator) {
-  BinaryOperatorKind opcode = Node.getOpcode();
-  return opcode == BO_Mul || opcode == BO_Div || opcode == BO_Rem ||
-         opcode == BO_Add || opcode == BO_Sub || opcode == BO_Shl ||
-         opcode == BO_Shr || opcode == BO_And || opcode == BO_Xor ||
-         opcode == BO_Or || opcode == BO_MulAssign || opcode == BO_DivAssign ||
-         opcode == BO_RemAssign || opcode == BO_AddAssign ||
-         opcode == BO_SubAssign || opcode == BO_ShlAssign ||
-         opcode == BO_ShrAssign || opcode == BO_AndAssign ||
-         opcode == BO_XorAssign || opcode == BO_OrAssign;
+  BinaryOperatorKind OpCode = Node.getOpcode();
+  return OpCode == BO_Mul || OpCode == BO_Div || OpCode == BO_Rem ||
+         OpCode == BO_Add || OpCode == BO_Sub || OpCode == BO_Shl ||
+         OpCode == BO_Shr || OpCode == BO_And || OpCode == BO_Xor ||
+         OpCode == BO_Or || OpCode == BO_MulAssign || OpCode == BO_DivAssign ||
+         OpCode == BO_RemAssign || OpCode == BO_AddAssign ||
+         OpCode == BO_SubAssign || OpCode == BO_ShlAssign ||
+         OpCode == BO_ShrAssign || OpCode == BO_AndAssign ||
+         OpCode == BO_XorAssign || OpCode == BO_OrAssign;
 }
 
 /// This matcher will match all arithmetic unary operators.
 AST_MATCHER(UnaryOperator, unaryArithmeticOperator) {
-  UnaryOperatorKind opcode = Node.getOpcode();
-  return opcode == UO_PostInc || opcode == UO_PostDec || opcode == UO_PreInc ||
-         opcode == UO_PreDec || opcode == UO_Plus || opcode == UO_Minus ||
-         opcode == UO_Not;
+  UnaryOperatorKind OpCode = Node.getOpcode();
+  return OpCode == UO_PostInc || OpCode == UO_PostDec || OpCode == UO_PreInc ||
+         OpCode == UO_PreDec || OpCode == UO_Plus || OpCode == UO_Minus ||
+         OpCode == UO_Not;
 }
 
 /// This matcher will match == and != binary operators.
 AST_MATCHER(BinaryOperator, binaryEqualityOperator) {
-  BinaryOperatorKind opcode = Node.getOpcode();
-  return opcode == BO_EQ || opcode == BO_NE;
+  BinaryOperatorKind OpCode = Node.getOpcode();
+  return OpCode == BO_EQ || OpCode == BO_NE;
 }
 
 /// This matcher will match floating point types.
 AST_MATCHER(QualType, isFloat) { return Node->isRealFloatingType(); }
 
 /// This matcher will match locations in system headers.  This is adopted from
 /// isExpansionInSystemHeader in newer clangs, but modified in order to work
 /// with old clangs that we use on infra.
 AST_MATCHER(BinaryOperator, isInSystemHeader) {
-  return IsInSystemHeader(Finder->getASTContext(), Node);
+  return ASTIsInSystemHeader(Finder->getASTContext(), Node);
 }
 
 /// This matcher will match locations in SkScalar.h.  This header contains a
 /// known NaN-testing expression which we would like to whitelist.
 AST_MATCHER(BinaryOperator, isInSkScalarDotH) {
   SourceLocation Loc = Node.getOperatorLoc();
   auto &SourceManager = Finder->getASTContext().getSourceManager();
   SmallString<1024> FileName = SourceManager.getFilename(Loc);
@@ -756,28 +759,28 @@ AST_MATCHER(CXXRecordDecl, needsMemMovab
 }
 
 /// This matcher will select classes which require all members to be memmovable
 AST_MATCHER(CXXRecordDecl, needsMemMovableMembers) {
   return MozChecker::hasCustomAnnotation(&Node, "moz_needs_memmovable_members");
 }
 
 AST_MATCHER(CXXConstructorDecl, isInterestingImplicitCtor) {
-  const CXXConstructorDecl *decl = Node.getCanonicalDecl();
+  const CXXConstructorDecl *Declaration = Node.getCanonicalDecl();
   return
       // Skip ignored namespaces and paths
-      !isInIgnoredNamespaceForImplicitCtor(decl) &&
-      !isIgnoredPathForImplicitCtor(decl) &&
+      !isInIgnoredNamespaceForImplicitCtor(Declaration) &&
+      !isIgnoredPathForImplicitCtor(Declaration) &&
       // We only want Converting constructors
-      decl->isConvertingConstructor(false) &&
+      Declaration->isConvertingConstructor(false) &&
       // We don't want copy of move constructors, as those are allowed to be
       // implicit
-      !decl->isCopyOrMoveConstructor() &&
+      !Declaration->isCopyOrMoveConstructor() &&
       // We don't want deleted constructors.
-      !decl->isDeleted();
+      !Declaration->isDeleted();
 }
 
 // We can't call this "isImplicit" since it clashes with an existing matcher in
 // clang.
 AST_MATCHER(CXXConstructorDecl, isMarkedImplicit) {
   return MozChecker::hasCustomAnnotation(&Node, "moz_implicit");
 }
 
@@ -796,22 +799,22 @@ AST_MATCHER(CXXConstructorDecl, isExplic
   return Node.isExplicit() && Node.isMoveConstructor();
 }
 
 AST_MATCHER(CXXConstructorDecl, isCompilerProvidedCopyConstructor) {
   return !Node.isUserProvided() && Node.isCopyConstructor();
 }
 
 AST_MATCHER(CallExpr, isAssertAssignmentTestFunc) {
-  static const std::string assertName = "MOZ_AssertAssignmentTest";
-  const FunctionDecl *method = Node.getDirectCallee();
+  static const std::string AssertName = "MOZ_AssertAssignmentTest";
+  const FunctionDecl *Method = Node.getDirectCallee();
 
-  return method
-      && method->getDeclName().isIdentifier()
-      && method->getName() == assertName;
+  return Method
+      && Method->getDeclName().isIdentifier()
+      && Method->getName() == AssertName;
 }
 
 AST_MATCHER(CXXRecordDecl, isLambdaDecl) {
   return Node.isLambda();
 }
 
 }
 }
@@ -835,32 +838,33 @@ void CustomTypeAnnotation::dumpAnnotatio
 
   AnnotationReason Reason = directAnnotationReason(T);
   for (;;) {
     switch (Reason.Kind) {
     case RK_ArrayElement:
       Diag.Report(Loc, ArrayID) << Pretty << T << Reason.Type;
       break;
     case RK_BaseClass: {
-      const CXXRecordDecl *Decl = T->getAsCXXRecordDecl();
-      assert(Decl && "This type should be a C++ class");
+      const CXXRecordDecl *Declaration = T->getAsCXXRecordDecl();
+      assert(Declaration && "This type should be a C++ class");
 
-      Diag.Report(Decl->getLocation(), InheritsID) << Pretty << T
+      Diag.Report(Declaration->getLocation(), InheritsID) << Pretty << T
                                                    << Reason.Type;
       break;
     }
     case RK_Field:
       Diag.Report(Reason.Field->getLocation(), MemberID)
           << Pretty << T << Reason.Field << Reason.Type;
       break;
     case RK_TemplateInherited: {
-      const CXXRecordDecl *Decl = T->getAsCXXRecordDecl();
-      assert(Decl && "This type should be a C++ class");
+      const CXXRecordDecl *Declaration = T->getAsCXXRecordDecl();
+      assert(Declaration && "This type should be a C++ class");
 
-      Diag.Report(Decl->getLocation(), TemplID) << Pretty << T << Reason.Type;
+      Diag.Report(Declaration->getLocation(), TemplID) << Pretty << T
+                                                   << Reason.Type;
       break;
     }
     default:
       // FIXME (bug 1203263): note the original annotation.
       return;
     }
 
     T = Reason.Type;
@@ -898,44 +902,44 @@ CustomTypeAnnotation::directAnnotationRe
     if (hasEffectiveAnnotation(Array->getElementType())) {
       AnnotationReason Reason = {Array->getElementType(), RK_ArrayElement,
                                  nullptr};
       Cache[Key] = Reason;
       return Reason;
     }
   }
 
-  // Recurse into base classes
-  if (const CXXRecordDecl *Decl = T->getAsCXXRecordDecl()) {
-    if (Decl->hasDefinition()) {
-      Decl = Decl->getDefinition();
+  // Recurse into Base classes
+  if (const CXXRecordDecl *Declaration = T->getAsCXXRecordDecl()) {
+    if (Declaration->hasDefinition()) {
+      Declaration = Declaration->getDefinition();
 
-      for (const CXXBaseSpecifier &Base : Decl->bases()) {
+      for (const CXXBaseSpecifier &Base : Declaration->bases()) {
         if (hasEffectiveAnnotation(Base.getType())) {
           AnnotationReason Reason = {Base.getType(), RK_BaseClass, nullptr};
           Cache[Key] = Reason;
           return Reason;
         }
       }
 
       // Recurse into members
-      for (const FieldDecl *Field : Decl->fields()) {
+      for (const FieldDecl *Field : Declaration->fields()) {
         if (hasEffectiveAnnotation(Field->getType())) {
           AnnotationReason Reason = {Field->getType(), RK_Field, Field};
           Cache[Key] = Reason;
           return Reason;
         }
       }
 
       // Recurse into template arguments if the annotation
       // MOZ_INHERIT_TYPE_ANNOTATIONS_FROM_TEMPLATE_ARGS is present
       if (MozChecker::hasCustomAnnotation(
-              Decl, "moz_inherit_type_annotations_from_template_args")) {
+              Declaration, "moz_inherit_type_annotations_from_template_args")) {
         const ClassTemplateSpecializationDecl *Spec =
-            dyn_cast<ClassTemplateSpecializationDecl>(Decl);
+            dyn_cast<ClassTemplateSpecializationDecl>(Declaration);
         if (Spec) {
           const TemplateArgumentList &Args = Spec->getTemplateArgs();
 
           AnnotationReason Reason = tmplArgAnnotationReason(Args.asArray());
           if (Reason.Kind != RK_None) {
             Cache[Key] = Reason;
             return Reason;
           }
@@ -965,55 +969,56 @@ CustomTypeAnnotation::tmplArgAnnotationR
       }
     }
   }
 
   AnnotationReason Reason = {QualType(), RK_None, nullptr};
   return Reason;
 }
 
-bool isPlacementNew(const CXXNewExpr *Expr) {
+bool isPlacementNew(const CXXNewExpr *Expression) {
   // Regular new expressions aren't placement new
-  if (Expr->getNumPlacementArgs() == 0)
+  if (Expression->getNumPlacementArgs() == 0)
     return false;
-  const FunctionDecl *Decl = Expr->getOperatorNew();
-  if (Decl && MozChecker::hasCustomAnnotation(Decl, "moz_heap_allocator")) {
+  const FunctionDecl *Declaration = Expression->getOperatorNew();
+  if (Declaration && MozChecker::hasCustomAnnotation(Declaration,
+                 "moz_heap_allocator")) {
     return false;
   }
   return true;
 }
 
 DiagnosticsMatcher::DiagnosticsMatcher() {
-  astMatcher.addMatcher(varDecl().bind("node"), &scopeChecker);
-  astMatcher.addMatcher(cxxNewExpr().bind("node"), &scopeChecker);
-  astMatcher.addMatcher(materializeTemporaryExpr().bind("node"), &scopeChecker);
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(varDecl().bind("node"), &Scope);
+  AstMatcher.addMatcher(cxxNewExpr().bind("node"), &Scope);
+  AstMatcher.addMatcher(materializeTemporaryExpr().bind("node"), &Scope);
+  AstMatcher.addMatcher(
       callExpr(callee(functionDecl(heapAllocator()))).bind("node"),
-      &scopeChecker);
-  astMatcher.addMatcher(parmVarDecl().bind("parm_vardecl"), &scopeChecker);
+      &Scope);
+  AstMatcher.addMatcher(parmVarDecl().bind("parm_vardecl"), &Scope);
 
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       callExpr(allOf(hasDeclaration(noArithmeticExprInArgs()),
                      anyOf(hasDescendant(
                                binaryOperator(
                                    allOf(binaryArithmeticOperator(),
                                          hasLHS(hasDescendant(declRefExpr())),
                                          hasRHS(hasDescendant(declRefExpr()))))
                                    .bind("node")),
                            hasDescendant(
                                unaryOperator(
                                    allOf(unaryArithmeticOperator(),
                                          hasUnaryOperand(allOf(
                                              hasType(builtinType()),
                                              anyOf(hasDescendant(declRefExpr()),
                                                    declRefExpr())))))
                                    .bind("node")))))
           .bind("call"),
-      &arithmeticArgChecker);
-  astMatcher.addMatcher(
+      &ArithmeticArg);
+  AstMatcher.addMatcher(
       cxxConstructExpr(
           allOf(hasDeclaration(noArithmeticExprInArgs()),
                 anyOf(hasDescendant(
                           binaryOperator(
                               allOf(binaryArithmeticOperator(),
                                     hasLHS(hasDescendant(declRefExpr())),
                                     hasRHS(hasDescendant(declRefExpr()))))
                               .bind("node")),
@@ -1021,122 +1026,125 @@ DiagnosticsMatcher::DiagnosticsMatcher()
                           unaryOperator(
                               allOf(unaryArithmeticOperator(),
                                     hasUnaryOperand(allOf(
                                         hasType(builtinType()),
                                         anyOf(hasDescendant(declRefExpr()),
                                               declRefExpr())))))
                               .bind("node")))))
           .bind("call"),
-      &arithmeticArgChecker);
+      &ArithmeticArg);
 
-  astMatcher.addMatcher(cxxRecordDecl(hasTrivialCtorDtor()).bind("node"),
-                        &trivialCtorDtorChecker);
+  AstMatcher.addMatcher(cxxRecordDecl(hasTrivialCtorDtor()).bind("node"),
+                        &TrivialCtorDtor);
 
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       binaryOperator(
           allOf(binaryEqualityOperator(),
                 hasLHS(has(
                     declRefExpr(hasType(qualType((isFloat())))).bind("lhs"))),
                 hasRHS(has(
                     declRefExpr(hasType(qualType((isFloat())))).bind("rhs"))),
                 unless(anyOf(isInSystemHeader(), isInSkScalarDotH()))))
           .bind("node"),
-      &nanExprChecker);
+      &NaNExpr);
 
   // First, look for direct parents of the MemberExpr.
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       callExpr(
           callee(functionDecl(hasNoAddRefReleaseOnReturnAttr()).bind("func")),
           hasParent(memberExpr(isAddRefOrRelease(), hasParent(callExpr()))
                         .bind("member")))
           .bind("node"),
-      &noAddRefReleaseOnReturnChecker);
+      &NoAddRefReleaseOnReturn);
   // Then, look for MemberExpr that need to be casted to the right type using
   // an intermediary CastExpr before we get to the CallExpr.
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       callExpr(
           callee(functionDecl(hasNoAddRefReleaseOnReturnAttr()).bind("func")),
           hasParent(castExpr(
               hasParent(memberExpr(isAddRefOrRelease(), hasParent(callExpr()))
                             .bind("member")))))
           .bind("node"),
-      &noAddRefReleaseOnReturnChecker);
+      &NoAddRefReleaseOnReturn);
 
   // We want to reject any code which captures a pointer to an object of a
   // refcounted type, and then lets that value escape. As a primitive analysis,
   // we reject any occurances of the lambda as a template parameter to a class
   // (which could allow it to escape), as well as any presence of such a lambda
   // in a return value (either from lambdas, or in c++14, auto functions).
   //
   // We check these lambdas' capture lists for raw pointers to refcounted types.
-  astMatcher.addMatcher(
-      functionDecl(returns(recordType(hasDeclaration(cxxRecordDecl(isLambdaDecl()).bind("decl"))))),
-      &refCountedInsideLambdaChecker);
-  astMatcher.addMatcher(lambdaExpr().bind("lambdaExpr"), &refCountedInsideLambdaChecker);
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
+      functionDecl(returns(recordType(hasDeclaration(cxxRecordDecl(
+        isLambdaDecl()).bind("decl"))))),
+      &RefCountedInsideLambda);
+  AstMatcher.addMatcher(lambdaExpr().bind("lambdaExpr"),
+      &RefCountedInsideLambda);
+  AstMatcher.addMatcher(
       classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
-        recordType(hasDeclaration(cxxRecordDecl(isLambdaDecl()).bind("decl")))))),
-      &refCountedInsideLambdaChecker);
+        recordType(hasDeclaration(cxxRecordDecl(
+          isLambdaDecl()).bind("decl")))))),
+      &RefCountedInsideLambda);
 
   // Older clang versions such as the ones used on the infra recognize these
   // conversions as 'operator _Bool', but newer clang versions recognize these
   // as 'operator bool'.
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       cxxMethodDecl(anyOf(hasName("operator bool"), hasName("operator _Bool")))
           .bind("node"),
-      &explicitOperatorBoolChecker);
+      &ExplicitOperatorBool);
 
-  astMatcher.addMatcher(cxxRecordDecl().bind("decl"), &noDuplicateRefCntMemberChecker);
+  AstMatcher.addMatcher(cxxRecordDecl().bind("decl"), &NoDuplicateRefCntMember);
 
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       classTemplateSpecializationDecl(
           allOf(hasAnyTemplateArgument(refersToType(hasVTable())),
                 hasNeedsNoVTableTypeAttr()))
           .bind("node"),
-      &needsNoVTableTypeChecker);
+      &NeedsNoVTableType);
 
   // Handle non-mem-movable template specializations
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       classTemplateSpecializationDecl(
           allOf(needsMemMovableTemplateArg(),
                 hasAnyTemplateArgument(refersToType(isNonMemMovable()))))
           .bind("specialization"),
-      &nonMemMovableTemplateArgChecker);
+      &NonMemMovableTemplateArg);
 
   // Handle non-mem-movable members
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       cxxRecordDecl(needsMemMovableMembers())
           .bind("decl"),
-      &nonMemMovableMemberChecker);
+      &NonMemMovableMember);
 
-  astMatcher.addMatcher(cxxConstructorDecl(isInterestingImplicitCtor(),
+  AstMatcher.addMatcher(cxxConstructorDecl(isInterestingImplicitCtor(),
                                            ofClass(allOf(isConcreteClass(),
                                                          decl().bind("class"))),
                                            unless(isMarkedImplicit()))
                             .bind("ctor"),
-                        &explicitImplicitChecker);
+                        &ExplicitImplicit);
 
-  astMatcher.addMatcher(varDecl(hasType(autoNonAutoableType())).bind("node"),
-                        &noAutoTypeChecker);
+  AstMatcher.addMatcher(varDecl(hasType(autoNonAutoableType())).bind("node"),
+                        &NoAutoType);
 
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       cxxConstructorDecl(isExplicitMoveConstructor()).bind("node"),
-      &noExplicitMoveConstructorChecker);
+      &NoExplicitMoveConstructor);
 
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       cxxConstructExpr(
           hasDeclaration(cxxConstructorDecl(isCompilerProvidedCopyConstructor(),
                                             ofClass(hasRefCntMember()))))
           .bind("node"),
-      &refCountedCopyConstructorChecker);
+      &RefCountedCopyConstructor);
 
-  astMatcher.addMatcher(
+  AstMatcher.addMatcher(
       callExpr(isAssertAssignmentTestFunc()).bind("funcCall"),
-      &assertAttributionChecker);
+      &AssertAttribution);
 }
 
 // These enum variants determine whether an allocation has occured in the code.
 enum AllocationVariety {
   AV_None,
   AV_Global,
   AV_Automatic,
   AV_Temporary,
@@ -1290,111 +1298,115 @@ void DiagnosticsMatcher::ScopeChecker::r
     NonHeapClass.reportErrorIfPresent(Diag, T, Loc, NonHeapID, HeapNoteID);
     break;
   }
 }
 
 void DiagnosticsMatcher::ArithmeticArgChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error,
       "cannot pass an arithmetic expression of built-in types to %0");
-  const Expr *expr = Result.Nodes.getNodeAs<Expr>("node");
-  if (const CallExpr *call = Result.Nodes.getNodeAs<CallExpr>("call")) {
-    Diag.Report(expr->getLocStart(), errorID) << call->getDirectCallee();
-  } else if (const CXXConstructExpr *ctr =
+  const Expr *Expression = Result.Nodes.getNodeAs<Expr>("node");
+  if (const CallExpr *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
+    Diag.Report(Expression->getLocStart(), ErrorID) << Call->getDirectCallee();
+  } else if (const CXXConstructExpr *Ctr =
                  Result.Nodes.getNodeAs<CXXConstructExpr>("call")) {
-    Diag.Report(expr->getLocStart(), errorID) << ctr->getConstructor();
+    Diag.Report(Expression->getLocStart(), ErrorID) << Ctr->getConstructor();
   }
 }
 
 void DiagnosticsMatcher::TrivialCtorDtorChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error,
       "class %0 must have trivial constructors and destructors");
-  const CXXRecordDecl *node = Result.Nodes.getNodeAs<CXXRecordDecl>("node");
+  const CXXRecordDecl *Node = Result.Nodes.getNodeAs<CXXRecordDecl>("node");
 
   // We need to accept non-constexpr trivial constructors as well. This occurs
   // when a struct contains pod members, which will not be initialized. As
   // constexpr values are initialized, the constructor is non-constexpr.
-  bool badCtor = !(node->hasConstexprDefaultConstructor() ||
-                   node->hasTrivialDefaultConstructor());
-  bool badDtor = !node->hasTrivialDestructor();
-  if (badCtor || badDtor)
-    Diag.Report(node->getLocStart(), errorID) << node;
+  bool BadCtor = !(Node->hasConstexprDefaultConstructor() ||
+                   Node->hasTrivialDefaultConstructor());
+  bool BadDtor = !Node->hasTrivialDestructor();
+  if (BadCtor || BadDtor)
+    Diag.Report(Node->getLocStart(), ErrorID) << Node;
 }
 
 void DiagnosticsMatcher::NaNExprChecker::run(
     const MatchFinder::MatchResult &Result) {
   if (!Result.Context->getLangOpts().CPlusPlus) {
     // mozilla::IsNaN is not usable in C, so there is no point in issuing these
     // warnings.
     return;
   }
 
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error, "comparing a floating point value to itself for "
                             "NaN checking can lead to incorrect results");
-  unsigned noteID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned NoteID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Note, "consider using mozilla::IsNaN instead");
-  const BinaryOperator *expr = Result.Nodes.getNodeAs<BinaryOperator>("node");
-  const DeclRefExpr *lhs = Result.Nodes.getNodeAs<DeclRefExpr>("lhs");
-  const DeclRefExpr *rhs = Result.Nodes.getNodeAs<DeclRefExpr>("rhs");
-  const ImplicitCastExpr *lhsExpr = dyn_cast<ImplicitCastExpr>(expr->getLHS());
-  const ImplicitCastExpr *rhsExpr = dyn_cast<ImplicitCastExpr>(expr->getRHS());
+  const BinaryOperator *Expression = Result.Nodes.getNodeAs<BinaryOperator>(
+    "node");
+  const DeclRefExpr *LHS = Result.Nodes.getNodeAs<DeclRefExpr>("lhs");
+  const DeclRefExpr *RHS = Result.Nodes.getNodeAs<DeclRefExpr>("rhs");
+  const ImplicitCastExpr *LHSExpr = dyn_cast<ImplicitCastExpr>(
+    Expression->getLHS());
+  const ImplicitCastExpr *RHSExpr = dyn_cast<ImplicitCastExpr>(
+    Expression->getRHS());
   // The AST subtree that we are looking for will look like this:
   // -BinaryOperator ==/!=
   //  |-ImplicitCastExpr LValueToRValue
   //  | |-DeclRefExpr
   //  |-ImplicitCastExpr LValueToRValue
   //    |-DeclRefExpr
   // The check below ensures that we are dealing with the correct AST subtree
   // shape, and
   // also that both of the found DeclRefExpr's point to the same declaration.
-  if (lhs->getFoundDecl() == rhs->getFoundDecl() && lhsExpr && rhsExpr &&
-      std::distance(lhsExpr->child_begin(), lhsExpr->child_end()) == 1 &&
-      std::distance(rhsExpr->child_begin(), rhsExpr->child_end()) == 1 &&
-      *lhsExpr->child_begin() == lhs && *rhsExpr->child_begin() == rhs) {
-    Diag.Report(expr->getLocStart(), errorID);
-    Diag.Report(expr->getLocStart(), noteID);
+  if (LHS->getFoundDecl() == RHS->getFoundDecl() && LHSExpr && RHSExpr &&
+      std::distance(LHSExpr->child_begin(), LHSExpr->child_end()) == 1 &&
+      std::distance(RHSExpr->child_begin(), RHSExpr->child_end()) == 1 &&
+      *LHSExpr->child_begin() == LHS && *RHSExpr->child_begin() == RHS) {
+    Diag.Report(Expression->getLocStart(), ErrorID);
+    Diag.Report(Expression->getLocStart(), NoteID);
   }
 }
 
 void DiagnosticsMatcher::NoAddRefReleaseOnReturnChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error, "%1 cannot be called on the return value of %0");
-  const Stmt *node = Result.Nodes.getNodeAs<Stmt>("node");
-  const FunctionDecl *func = Result.Nodes.getNodeAs<FunctionDecl>("func");
-  const MemberExpr *member = Result.Nodes.getNodeAs<MemberExpr>("member");
-  const CXXMethodDecl *method =
-      dyn_cast<CXXMethodDecl>(member->getMemberDecl());
+  const Stmt *Node = Result.Nodes.getNodeAs<Stmt>("node");
+  const FunctionDecl *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
+  const MemberExpr *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
+  const CXXMethodDecl *Method =
+      dyn_cast<CXXMethodDecl>(Member->getMemberDecl());
 
-  Diag.Report(node->getLocStart(), errorID) << func << method;
+  Diag.Report(Node->getLocStart(), ErrorID) << Func << Method;
 }
 
 void DiagnosticsMatcher::RefCountedInsideLambdaChecker::run(
     const MatchFinder::MatchResult &Result) {
   static DenseSet<const CXXRecordDecl*> CheckedDecls;
 
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error,
       "Refcounted variable %0 of type %1 cannot be captured by a lambda");
-  unsigned noteID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned NoteID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Note, "Please consider using a smart pointer");
 
   const CXXRecordDecl *Lambda = Result.Nodes.getNodeAs<CXXRecordDecl>("decl");
 
-  if (const LambdaExpr *OuterLambda = Result.Nodes.getNodeAs<LambdaExpr>("lambdaExpr")) {
+  if (const LambdaExpr *OuterLambda =
+    Result.Nodes.getNodeAs<LambdaExpr>("lambdaExpr")) {
     const CXXMethodDecl *OpCall = OuterLambda->getCallOperator();
     QualType ReturnTy = OpCall->getReturnType();
     if (const CXXRecordDecl *Record = ReturnTy->getAsCXXRecordDecl()) {
       Lambda = Record;
     }
   }
 
   if (!Lambda || !Lambda->isLambda()) {
@@ -1407,193 +1419,193 @@ void DiagnosticsMatcher::RefCountedInsid
   }
   CheckedDecls.insert(Lambda);
 
   for (const LambdaCapture Capture : Lambda->captures()) {
     if (Capture.capturesVariable() && Capture.getCaptureKind() != LCK_ByRef) {
       QualType Pointee = Capture.getCapturedVar()->getType()->getPointeeType();
 
       if (!Pointee.isNull() && isClassRefCounted(Pointee)) {
-        Diag.Report(Capture.getLocation(), errorID) << Capture.getCapturedVar()
+        Diag.Report(Capture.getLocation(), ErrorID) << Capture.getCapturedVar()
                                                     << Pointee;
-        Diag.Report(Capture.getLocation(), noteID);
+        Diag.Report(Capture.getLocation(), NoteID);
         return;
       }
     }
   }
 }
 
 void DiagnosticsMatcher::ExplicitOperatorBoolChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error, "bad implicit conversion operator for %0");
-  unsigned noteID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned NoteID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Note, "consider adding the explicit keyword to %0");
-  const CXXConversionDecl *method =
+  const CXXConversionDecl *Method =
       Result.Nodes.getNodeAs<CXXConversionDecl>("node");
-  const CXXRecordDecl *clazz = method->getParent();
+  const CXXRecordDecl *Clazz = Method->getParent();
 
-  if (!method->isExplicitSpecified() &&
-      !MozChecker::hasCustomAnnotation(method, "moz_implicit") &&
-      !IsInSystemHeader(method->getASTContext(), *method) &&
-      isInterestingDeclForImplicitConversion(method)) {
-    Diag.Report(method->getLocStart(), errorID) << clazz;
-    Diag.Report(method->getLocStart(), noteID) << "'operator bool'";
+  if (!Method->isExplicitSpecified() &&
+      !MozChecker::hasCustomAnnotation(Method, "moz_implicit") &&
+      !ASTIsInSystemHeader(Method->getASTContext(), *Method) &&
+      isInterestingDeclForImplicitConversion(Method)) {
+    Diag.Report(Method->getLocStart(), ErrorID) << Clazz;
+    Diag.Report(Method->getLocStart(), NoteID) << "'operator bool'";
   }
 }
 
 void DiagnosticsMatcher::NoDuplicateRefCntMemberChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
   const CXXRecordDecl *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl");
-  const FieldDecl *refCntMember = getClassRefCntMember(D);
-  const FieldDecl *foundRefCntBase = nullptr;
+  const FieldDecl *RefCntMember = getClassRefCntMember(D);
+  const FieldDecl *FoundRefCntBase = nullptr;
 
   if (!D->hasDefinition())
     return;
   D = D->getDefinition();
 
   // If we don't have an mRefCnt member, and we have less than 2 superclasses,
   // we don't have to run this loop, as neither case will ever apply.
-  if (!refCntMember && D->getNumBases() < 2) {
+  if (!RefCntMember && D->getNumBases() < 2) {
     return;
   }
 
   // Check every superclass for whether it has a base with a refcnt member, and
   // warn for those which do
-  for (auto &base : D->bases()) {
+  for (auto &Base : D->bases()) {
     // Determine if this base class has an mRefCnt member
-    const FieldDecl *baseRefCntMember = getBaseRefCntMember(base.getType());
+    const FieldDecl *BaseRefCntMember = getBaseRefCntMember(Base.getType());
 
-    if (baseRefCntMember) {
-      if (refCntMember) {
+    if (BaseRefCntMember) {
+      if (RefCntMember) {
         // We have an mRefCnt, and superclass has an mRefCnt
-        unsigned error = Diag.getDiagnosticIDs()->getCustomDiagID(
+        unsigned Error = Diag.getDiagnosticIDs()->getCustomDiagID(
             DiagnosticIDs::Error,
             "Refcounted record %0 has multiple mRefCnt members");
-        unsigned note1 = Diag.getDiagnosticIDs()->getCustomDiagID(
+        unsigned Note1 = Diag.getDiagnosticIDs()->getCustomDiagID(
             DiagnosticIDs::Note, "Superclass %0 also has an mRefCnt member");
-        unsigned note2 = Diag.getDiagnosticIDs()->getCustomDiagID(
+        unsigned Note2 = Diag.getDiagnosticIDs()->getCustomDiagID(
             DiagnosticIDs::Note,
             "Consider using the _INHERITED macros for AddRef and Release here");
 
-        Diag.Report(D->getLocStart(), error) << D;
-        Diag.Report(baseRefCntMember->getLocStart(), note1)
-          << baseRefCntMember->getParent();
-        Diag.Report(refCntMember->getLocStart(), note2);
+        Diag.Report(D->getLocStart(), Error) << D;
+        Diag.Report(BaseRefCntMember->getLocStart(), Note1)
+          << BaseRefCntMember->getParent();
+        Diag.Report(RefCntMember->getLocStart(), Note2);
       }
 
-      if (foundRefCntBase) {
-        unsigned error = Diag.getDiagnosticIDs()->getCustomDiagID(
+      if (FoundRefCntBase) {
+        unsigned Error = Diag.getDiagnosticIDs()->getCustomDiagID(
             DiagnosticIDs::Error,
             "Refcounted record %0 has multiple superclasses with mRefCnt members");
-        unsigned note = Diag.getDiagnosticIDs()->getCustomDiagID(
+        unsigned Note = Diag.getDiagnosticIDs()->getCustomDiagID(
             DiagnosticIDs::Note,
             "Superclass %0 has an mRefCnt member");
 
         // superclass has mRefCnt, and another superclass also has an mRefCnt
-        Diag.Report(D->getLocStart(), error) << D;
-        Diag.Report(baseRefCntMember->getLocStart(), note)
-          << baseRefCntMember->getParent();
-        Diag.Report(foundRefCntBase->getLocStart(), note)
-          << foundRefCntBase->getParent();
+        Diag.Report(D->getLocStart(), Error) << D;
+        Diag.Report(BaseRefCntMember->getLocStart(), Note)
+          << BaseRefCntMember->getParent();
+        Diag.Report(FoundRefCntBase->getLocStart(), Note)
+          << FoundRefCntBase->getParent();
       }
 
       // Record that we've found a base with a mRefCnt member
-      foundRefCntBase = baseRefCntMember;
+      FoundRefCntBase = BaseRefCntMember;
     }
   }
 }
 
 void DiagnosticsMatcher::NeedsNoVTableTypeChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error,
       "%0 cannot be instantiated because %1 has a VTable");
-  unsigned noteID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned NoteID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Note, "bad instantiation of %0 requested here");
 
-  const ClassTemplateSpecializationDecl *specialization =
+  const ClassTemplateSpecializationDecl *Specialization =
       Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("node");
 
   // Get the offending template argument
-  QualType offender;
-  const TemplateArgumentList &args =
-      specialization->getTemplateInstantiationArgs();
-  for (unsigned i = 0; i < args.size(); ++i) {
-    offender = args[i].getAsType();
-    if (typeHasVTable(offender)) {
+  QualType Offender;
+  const TemplateArgumentList &Args =
+      Specialization->getTemplateInstantiationArgs();
+  for (unsigned i = 0; i < Args.size(); ++i) {
+    Offender = Args[i].getAsType();
+    if (typeHasVTable(Offender)) {
       break;
     }
   }
 
-  Diag.Report(specialization->getLocStart(), errorID) << specialization
-                                                      << offender;
-  Diag.Report(specialization->getPointOfInstantiation(), noteID)
-      << specialization;
+  Diag.Report(Specialization->getLocStart(), ErrorID) << Specialization
+                                                      << Offender;
+  Diag.Report(Specialization->getPointOfInstantiation(), NoteID)
+      << Specialization;
 }
 
 void DiagnosticsMatcher::NonMemMovableTemplateArgChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error,
       "Cannot instantiate %0 with non-memmovable template argument %1");
-  unsigned note1ID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned Note1ID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Note, "instantiation of %0 requested here");
 
   // Get the specialization
-  const ClassTemplateSpecializationDecl *specialization =
+  const ClassTemplateSpecializationDecl *Specialization =
       Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("specialization");
-  SourceLocation requestLoc = specialization->getPointOfInstantiation();
+  SourceLocation RequestLoc = Specialization->getPointOfInstantiation();
 
   // Report an error for every template argument which is non-memmovable
-  const TemplateArgumentList &args =
-      specialization->getTemplateInstantiationArgs();
-  for (unsigned i = 0; i < args.size(); ++i) {
-    QualType argType = args[i].getAsType();
-    if (NonMemMovable.hasEffectiveAnnotation(argType)) {
-      Diag.Report(specialization->getLocation(), errorID) << specialization
-                                                          << argType;
+  const TemplateArgumentList &Args =
+      Specialization->getTemplateInstantiationArgs();
+  for (unsigned i = 0; i < Args.size(); ++i) {
+    QualType ArgType = Args[i].getAsType();
+    if (NonMemMovable.hasEffectiveAnnotation(ArgType)) {
+      Diag.Report(Specialization->getLocation(), ErrorID) << Specialization
+                                                          << ArgType;
       // XXX It would be really nice if we could get the instantiation stack
       // information
       // from Sema such that we could print a full template instantiation stack,
       // however,
       // it seems as though that information is thrown out by the time we get
       // here so we
       // can only report one level of template specialization (which in many
       // cases won't
       // be useful)
-      Diag.Report(requestLoc, note1ID) << specialization;
-      NonMemMovable.dumpAnnotationReason(Diag, argType, requestLoc);
+      Diag.Report(RequestLoc, Note1ID) << Specialization;
+      NonMemMovable.dumpAnnotationReason(Diag, ArgType, RequestLoc);
     }
   }
 }
 
 void DiagnosticsMatcher::NonMemMovableMemberChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned errorID = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error,
       "class %0 cannot have non-memmovable member %1 of type %2");
 
   // Get the specialization
-  const CXXRecordDecl* Decl =
+  const CXXRecordDecl* Declaration =
       Result.Nodes.getNodeAs<CXXRecordDecl>("decl");
 
   // Report an error for every member which is non-memmovable
-  for (const FieldDecl *Field : Decl->fields()) {
+  for (const FieldDecl *Field : Declaration->fields()) {
     QualType Type = Field->getType();
     if (NonMemMovable.hasEffectiveAnnotation(Type)) {
-      Diag.Report(Field->getLocation(), errorID) << Decl
+      Diag.Report(Field->getLocation(), ErrorID) << Declaration
                                                  << Field
                                                  << Type;
-      NonMemMovable.dumpAnnotationReason(Diag, Type, Decl->getLocation());
+      NonMemMovable.dumpAnnotationReason(Diag, Type, Declaration->getLocation());
     }
   }
 }
 
 void DiagnosticsMatcher::ExplicitImplicitChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
   unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
@@ -1602,19 +1614,20 @@ void DiagnosticsMatcher::ExplicitImplici
       DiagnosticIDs::Note,
       "consider adding the explicit keyword to the constructor");
 
   // We've already checked everything in the matcher, so we just have to report
   // the error.
 
   const CXXConstructorDecl *Ctor =
       Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
-  const CXXRecordDecl *Decl = Result.Nodes.getNodeAs<CXXRecordDecl>("class");
+  const CXXRecordDecl *Declaration =
+      Result.Nodes.getNodeAs<CXXRecordDecl>("class");
 
-  Diag.Report(Ctor->getLocation(), ErrorID) << Decl->getDeclName();
+  Diag.Report(Ctor->getLocation(), ErrorID) << Declaration->getDeclName();
   Diag.Report(Ctor->getLocation(), NoteID);
 }
 
 void DiagnosticsMatcher::NoAutoTypeChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
   unsigned ErrorID = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error, "Cannot use auto to declare a variable of type %0");
@@ -1661,47 +1674,47 @@ void DiagnosticsMatcher::RefCountedCopyC
 
   Diag.Report(E->getLocation(), ErrorID);
   Diag.Report(E->getLocation(), NoteID);
 }
 
 void DiagnosticsMatcher::AssertAssignmentChecker::run(
     const MatchFinder::MatchResult &Result) {
   DiagnosticsEngine &Diag = Result.Context->getDiagnostics();
-  unsigned assignInsteadOfComp = Diag.getDiagnosticIDs()->getCustomDiagID(
+  unsigned AssignInsteadOfComp = Diag.getDiagnosticIDs()->getCustomDiagID(
       DiagnosticIDs::Error, "Forbidden assignment in assert expression");
-  const CallExpr *funcCall = Result.Nodes.getNodeAs<CallExpr>("funcCall");
+  const CallExpr *FuncCall = Result.Nodes.getNodeAs<CallExpr>("funcCall");
 
-  if (funcCall && HasSideEffectAssignment(funcCall)) {
-    Diag.Report(funcCall->getLocStart(), assignInsteadOfComp);
+  if (FuncCall && hasSideEffectAssignment(FuncCall)) {
+    Diag.Report(FuncCall->getLocStart(), AssignInsteadOfComp);
   }
 }
 
 class MozCheckAction : public PluginASTAction {
 public:
   ASTConsumerPtr CreateASTConsumer(CompilerInstance &CI,
-                                   StringRef fileName) override {
+                                   StringRef FileName) override {
 #if CLANG_VERSION_FULL >= 306
-    std::unique_ptr<MozChecker> checker(llvm::make_unique<MozChecker>(CI));
-    ASTConsumerPtr other(checker->getOtherConsumer());
+    std::unique_ptr<MozChecker> Checker(llvm::make_unique<MozChecker>(CI));
+    ASTConsumerPtr Other(Checker->getOtherConsumer());
 
-    std::vector<ASTConsumerPtr> consumers;
-    consumers.push_back(std::move(checker));
-    consumers.push_back(std::move(other));
-    return llvm::make_unique<MultiplexConsumer>(std::move(consumers));
+    std::vector<ASTConsumerPtr> Consumers;
+    Consumers.push_back(std::move(Checker));
+    Consumers.push_back(std::move(Other));
+    return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
 #else
-    MozChecker *checker = new MozChecker(CI);
+    MozChecker *Checker = new MozChecker(CI);
 
-    ASTConsumer *consumers[] = {checker, checker->getOtherConsumer()};
-    return new MultiplexConsumer(consumers);
+    ASTConsumer *Consumers[] = {Checker, Checker->getOtherConsumer()};
+    return new MultiplexConsumer(Consumers);
 #endif
   }
 
   bool ParseArgs(const CompilerInstance &CI,
-                 const std::vector<std::string> &args) override {
+                 const std::vector<std::string> &Args) override {
     return true;
   }
 };
 }
 
 static FrontendPluginRegistry::Add<MozCheckAction> X("moz-check",
                                                      "check moz action");
 // Export the registry on Windows.

--- a/dom/base/Navigator.cpp
+++ b/dom/base/Navigator.cpp
@@ -115,20 +115,16 @@
 #endif
 #include "mozilla/dom/ContentChild.h"
 
 #ifdef MOZ_EME
 #include "mozilla/EMEUtils.h"
 #include "mozilla/DetailedPromise.h"
 #endif
 
-#ifdef MOZ_WIDGET_GONK
-#include <cutils/properties.h>
-#endif
-
 namespace mozilla {
 namespace dom {
 
 static bool sVibratorEnabled   = false;
 static uint32_t sMaxVibrateMS  = 0;
 static uint32_t sMaxVibrateListLen = 0;
 static const char* kVibrationPermissionType = "vibration";
 
@@ -1634,167 +1630,16 @@ Navigator::PublishServer(const nsAString
                    },
                    [domPromise] (nsresult aStatus) {
                      domPromise->MaybeReject(aStatus);
                    });
 
   return domPromise.forget();
 }
 
-already_AddRefed<Promise>
-Navigator::GetFeature(const nsAString& aName, ErrorResult& aRv)
-{
-  nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(mWindow);
-  RefPtr<Promise> p = Promise::Create(go, aRv);
-  if (aRv.Failed()) {
-    return nullptr;
-  }
-
-#if defined(XP_LINUX)
-  if (aName.EqualsLiteral("hardware.memory")) {
-    // with seccomp enabled, fopen() should be in a non-sandboxed process
-    if (XRE_IsParentProcess()) {
-      uint32_t memLevel = mozilla::hal::GetTotalSystemMemoryLevel();
-      if (memLevel == 0) {
-        p->MaybeReject(NS_ERROR_NOT_AVAILABLE);
-        return p.forget();
-      }
-      p->MaybeResolve((int)memLevel);
-    } else {
-      mozilla::dom::ContentChild* cc =
-        mozilla::dom::ContentChild::GetSingleton();
-      RefPtr<Promise> ipcRef(p);
-      cc->SendGetSystemMemory(reinterpret_cast<uint64_t>(ipcRef.forget().take()));
-    }
-    return p.forget();
-  } // hardware.memory
-#endif
-
-#ifdef MOZ_WIDGET_GONK
-  if (StringBeginsWith(aName, NS_LITERAL_STRING("acl.")) &&
-      (aName.EqualsLiteral("acl.version") || CheckPermission("external-app"))) {
-    char value[PROPERTY_VALUE_MAX];
-    nsCString propertyKey("persist.");
-    propertyKey.Append(NS_ConvertUTF16toUTF8(aName));
-    uint32_t len = property_get(propertyKey.get(), value, nullptr);
-    if (len > 0) {
-      p->MaybeResolve(NS_ConvertUTF8toUTF16(value));
-      return p.forget();
-    }
-  }
-#endif
-
-  // Mirror the dom.apps.developer_mode pref to let apps get it read-only.
-  if (aName.EqualsLiteral("dom.apps.developer_mode")) {
-    p->MaybeResolve(Preferences::GetBool("dom.apps.developer_mode", false));
-    return p.forget();
-  }
-
-  p->MaybeResolveWithUndefined();
-  return p.forget();
-}
-
-already_AddRefed<Promise>
-Navigator::HasFeature(const nsAString& aName, ErrorResult& aRv)
-{
-  nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(mWindow);
-  RefPtr<Promise> p = Promise::Create(go, aRv);
-  if (aRv.Failed()) {
-    return nullptr;
-  }
-
-  // Hardcoded extensions features which are b2g specific.
-#ifdef MOZ_B2G
-  if (aName.EqualsLiteral("web-extensions") ||
-      aName.EqualsLiteral("late-customization")) {
-    p->MaybeResolve(true);
-    return p.forget();
-  }
-#endif
-
-  // Hardcoded manifest features. Some are still b2g specific.
-  const char manifestFeatures[][64] = {
-    "manifest.origin"
-  , "manifest.redirects"
-#ifdef MOZ_B2G
-  , "manifest.chrome.navigation"
-  , "manifest.precompile"
-  , "manifest.role.homescreen"
-#endif
-  };
-
-  nsAutoCString feature = NS_ConvertUTF16toUTF8(aName);
-  for (uint32_t i = 0; i < MOZ_ARRAY_LENGTH(manifestFeatures); i++) {
-    if (feature.Equals(manifestFeatures[i])) {
-      p->MaybeResolve(true);
-      return p.forget();
-    }
-  }
-
-  NS_NAMED_LITERAL_STRING(apiWindowPrefix, "api.window.");
-  if (StringBeginsWith(aName, apiWindowPrefix)) {
-    const nsAString& featureName = Substring(aName, apiWindowPrefix.Length());
-
-    // Temporary hardcoded entry points due to technical constraints
-    if (featureName.EqualsLiteral("Navigator.mozTCPSocket")) {
-      p->MaybeResolve(Preferences::GetBool("dom.mozTCPSocket.enabled"));
-      return p.forget();
-    }
-
-    if (featureName.EqualsLiteral("Navigator.mozMobileConnections") ||
-        featureName.EqualsLiteral("MozMobileNetworkInfo")) {
-      p->MaybeResolve(Preferences::GetBool("dom.mobileconnection.enabled"));
-      return p.forget();
-    }
-
-    if (featureName.EqualsLiteral("Navigator.mozInputMethod")) {
-      p->MaybeResolve(Preferences::GetBool("dom.mozInputMethod.enabled"));
-      return p.forget();
-    }
-
-    if (featureName.EqualsLiteral("Navigator.getDeviceStorage")) {
-      p->MaybeResolve(Preferences::GetBool("device.storage.enabled"));
-      return p.forget();
-    }
-
-    if (featureName.EqualsLiteral("Navigator.mozNetworkStats")) {
-      p->MaybeResolve(Preferences::GetBool("dom.mozNetworkStats.enabled"));
-      return p.forget();
-    }
-
-    if (featureName.EqualsLiteral("Navigator.push")) {
-      p->MaybeResolve(Preferences::GetBool("services.push.enabled"));
-      return p.forget();
-    }
-
-    if (featureName.EqualsLiteral("Navigator.mozAlarms")) {
-      p->MaybeResolve(Preferences::GetBool("dom.mozAlarms.enabled"));
-      return p.forget();
-    }
-
-    if (featureName.EqualsLiteral("Navigator.mozCameras")) {
-      p->MaybeResolve(true);
-      return p.forget();
-    }
-
-    if (featureName.EqualsLiteral("XMLHttpRequest.mozSystem")) {
-      p->MaybeResolve(true);
-      return p.forget();
-    }
-
-    p->MaybeResolveWithUndefined();
-    return p.forget();
-  }
-
-  // resolve with <undefined> because the feature name is not supported
-  p->MaybeResolveWithUndefined();
-
-  return p.forget();
-}
-
 PowerManager*
 Navigator::GetMozPower(ErrorResult& aRv)
 {
   if (!mPowerManager) {
     if (!mWindow) {
       aRv.Throw(NS_ERROR_UNEXPECTED);
       return nullptr;
     }

--- a/dom/base/Navigator.h
+++ b/dom/base/Navigator.h
@@ -180,23 +180,16 @@ public:
                                nsIURI* aURI,
                                bool aIsCallerChrome,
                                nsAString& aUserAgent);
 
   // Clears the user agent cache by calling:
   // NavigatorBinding::ClearCachedUserAgentValue(this);
   void ClearUserAgentCache();
 
-  // Feature Detection API
-  already_AddRefed<Promise> GetFeature(const nsAString& aName,
-                                       ErrorResult& aRv);
-
-  already_AddRefed<Promise> HasFeature(const nsAString &aName,
-                                       ErrorResult& aRv);
-
   bool Vibrate(uint32_t aDuration);
   bool Vibrate(const nsTArray<uint32_t>& aDuration);
   void SetVibrationPermission(bool aPermitted, bool aPersistent);
   uint32_t MaxTouchPoints();
   void GetAppCodeName(nsString& aAppCodeName, ErrorResult& aRv)
   {
     aRv = GetAppCodeName(aAppCodeName);
   }

--- a/dom/base/test/chrome.ini
+++ b/dom/base/test/chrome.ini
@@ -21,11 +21,9 @@ support-files = file_navigator_resolve_i
 subsuite = clipboard
 [test_messagemanager_principal.html]
 [test_messagemanager_send_principal.html]
 skip-if = buildapp == 'mulet'
 [test_bug945152.html]
 [test_bug1008126.html]
 [test_sandboxed_blob_uri.html]
 [test_websocket_frame.html]
-[test_getFeature_with_perm.html]
-[test_hasFeature.html]
 [test_mozbrowser_apis_allowed.html]

deleted file mode 100644
--- a/dom/base/test/test_getFeature_with_perm.html
+++ /dev/null
@@ -1,135 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<!--
-https://bugzilla.mozilla.org/show_bug.cgi?id=979109
--->
-<head>
-  <meta charset="utf-8">
-  <title>Test for Bug 979109</title>
-  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
-  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
-</head>
-<body>
-<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=983502">Mozilla Bug 983502</a>
-<script type="application/javascript">
-
-function testSupported() {
-  var mem;
-  navigator.getFeature("hardware.memory").then(function(mem) {
-
-    var isLinux = (navigator.platform.indexOf('Linux') != -1);
-    var isAndroid = !!navigator.userAgent.includes("Android");
-    var isB2G = !isAndroid && /Mobile|Tablet/.test(navigator.userAgent);
-
-    if (isLinux) {
-      info("It is Linux version:");
-    }
-    if (isAndroid) {
-      info("It is Android version");
-    }
-    if (isB2G) {
-      info("It is B2G version");
-    }
-
-    if (isLinux || isAndroid || isB2G) {
-      ok(typeof mem === 'number' && (mem) % 1 === 0, "We should receive an integer on this platform");
-      ok(mem > 0, "hardware.memory is supported on this platform. mem=" + mem + "MiB");
-    } else {
-      ok(typeof mem === 'undefined', "hardware.memory is not support on this platform");
-    }
-
-    runNextTest();
-
-  },function(mem) {
-    ok(false, "The Promise should not be rejected");
-  });
-}
-
-function testNotSupported() {
-  var tv;
-  navigator.getFeature("hardware.tv").then(function(tv) {
-    ok(typeof tv === 'undefined', "Resolve the Promise with undefined value (hardware.tv)");
-    runNextTest();
-  },function(tv) {
-    ok(false, "The Promise should not be rejected");
-  });
-}
-
-function testNotSupportedManifest() {
-  navigator.getFeature("manifest.origin").then(function(feature) {
-    ok(typeof feature == 'undefined', "manifest.* resolves with undefined on getFeature");
-    runNextTest();
-  }, function() {
-    ok(false, "The Promise should not be rejected");
-  });
-}
-
-function createManifestTest(aFeature) {
-  return function() {
-    var res;
-    navigator.hasFeature(aFeature).then(function(res) {
-      ok(res === true, "Resolve the Promise with 'true' for " + aFeature);
-      runNextTest();
-    }, function(tv) {
-      ok(false, "The Promise should not be rejected");
-    });
-  }
-}
-
-function testDevMode(aExpected) {
-  return function() {
-    navigator.getFeature("dom.apps.developer_mode").then(res => {
-      is(res, aExpected, "dom.apps.developer_mode is " + aExpected);
-      runNextTest();
-    }, function() {
-      ok(false, "The Promise should not be rejected");
-    });
-  }
-}
-
-function enableDevMode() {
-  SpecialPowers.pushPrefEnv({"set": [["dom.apps.developer_mode", true]]}, runNextTest);
-}
-
-var currentTest = -1;
-var tests = [
-  testNotSupported,
-  testNotSupportedManifest,
-  testSupported,
-  createManifestTest("manifest.origin"),
-  createManifestTest("manifest.redirects"),
-  testDevMode(false),
-  enableDevMode,
-  testDevMode(true)
-];
-
-function runNextTest() {
-  currentTest++;
-  if (currentTest < tests.length) {
-    tests[currentTest]();
-  } else {
-    SimpleTest.finish();
-  }
-}
-
-info("About to run " + tests.length + " tests");
-
-ok('getFeature' in navigator, "navigator.getFeature should exist");
-ok('hasFeature' in navigator, "navigator.hasFeature should exist");
-// B2G specific manifest features.
-// Touching navigator before pushPermissions makes it fail.
-if (!navigator.userAgent.includes("Android") &&
-      /Mobile|Tablet/.test(navigator.userAgent)) {
-  info("Adding B2G specific tests");
-  tests.push(createManifestTest("manifest.chrome.navigation"));
-  tests.push(createManifestTest("manifest.precompile"));
-  tests.push(createManifestTest("manifest.role.homescreen"));
-}
-runNextTest();
-ok(true, "Test DONE");
-
-SimpleTest.waitForExplicitFinish();
-
-</script>
-</body>
-</html>

deleted file mode 100644
--- a/dom/base/test/test_hasFeature.html
+++ /dev/null
@@ -1,101 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<!--
-https://bugzilla.mozilla.org/show_bug.cgi?id=1009645
--->
-<head>
-  <meta charset="utf-8">
-  <title>Test for Bug 1009645</title>
-  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
-  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
-</head>
-<body>
-<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1009645">Mozilla Bug 1009645</a>
-<script type="application/javascript">
-
-var b2gOnly;
-
-function pref(name) {
-  try {
-    return SpecialPowers.getBoolPref(name);
-  } catch (e) {
-    return false;
-  }
-}
-
-function testAPIs() {
-  var APIEndPoints = [
-    { name: "MozMobileNetworkInfo", enabled: pref("dom.mobileconnection.enabled") },
-    // { name: "Navigator.mozBluetooth", enabled: b2gOnly }, // conditional on MOZ_B2G_BT, tricky to test
-    // Bug 1266035 { name: "Navigator.mozContacts", enabled: pref("dom.mozContacts.enabled") },
-    { name: "Navigator.getDeviceStorage", enabled: pref("device.storage.enabled") },
-    // Bug 1266035 { name: "Navigator.addIdleObserver", enabled: true },
-    { name: "Navigator.mozNetworkStats", enabled: pref("dom.mozNetworkStats.enabled") },
-    { name: "Navigator.push", enabled: pref("services.push.enabled") },
-    // { name: "Navigator.mozTime", enabled: b2gOnly }, // conditional on MOZ_TIME_MANAGER, tricky to test
-    // { name: "Navigator.mozFMRadio", enabled: b2gOnly }, // conditional on MOZ_B2G_FM, tricky to test
-    { name: "Navigator.mozCameras", enabled: true },
-    { name: "Navigator.mozAlarms", enabled: pref("dom.mozAlarms.enabled") },
-    { name: "Navigator.mozTCPSocket", enabled: pref("dom.mozTCPSocket.enabled") },
-    { name: "Navigator.mozInputMethod", enabled: pref("dom.mozInputMethod.enabled") },
-    { name: "Navigator.mozMobileConnections", enabled: pref("dom.mobileconnection.enabled") },
-    { name: "XMLHttpRequest.mozSystem", enabled: true }
-  ];
-
-  var promises = [];
-  APIEndPoints.forEach(function(v) {
-    promises.push(navigator.hasFeature("api.window." + v.name));
-  });
-
-  return Promise.all(promises).then(function(values) {
-    for (var i = 0; i < values.length; ++i) {
-      is(values[i], APIEndPoints[i].enabled,
-         "Endpoint " + APIEndPoints[i].name + " resolved with the correct value. " +
-         "If this is failing because you're changing how an API is exposed, you " +
-         "must contact the Marketplace team to let them know about the change.");
-    }
-  }, function() {
-    ok(false, "The Promise should not be rejected");
-  });
-}
-
-function testExtensions() {
-  if (!b2gOnly) {
-    return Promise.resolve();
-  }
-
-  var builtInFeatures = [
-    {feature: "web-extensions", value: true},
-    {feature: "late-customization", value: true}
-  ];
-
-  builtInFeatures.forEach(function(x) {
-    navigator.hasFeature(x.feature).then(function(value) {
-      is(value, x.value, "Resolve the Promise with " + value + " for feature: " + x.feature);
-    }).catch(function(ex) {
-      ok(false, "The Promise should not be rejected");
-    });
-  });
-  return Promise.resolve();
-}
-
-SpecialPowers.pushPermissions([
-  {type: "feature-detection", allow: true, context: document}
-], function() {
-  b2gOnly = (function() {
-    var isAndroid = !!navigator.userAgent.includes("Android");
-    var isMulet = pref("b2g.is_mulet");
-    var isB2g = isMulet || (!isAndroid && /Mobile|Tablet/.test(navigator.userAgent));
-    return isB2g ? true : undefined;
-  })();
-
-  ok('hasFeature' in navigator, "navigator.hasFeature should exist");
-  testAPIs().then(testExtensions).catch(function(e) {
-    ok(false, "The Promise should not be rejected: " + e);
-  }).then(SimpleTest.finish);
-});
-
-SimpleTest.waitForExplicitFinish();
-</script>
-</body>
-</html>

--- a/dom/browser-element/BrowserElementParent.js
+++ b/dom/browser-element/BrowserElementParent.js
@@ -784,49 +784,35 @@ BrowserElementParent.prototype = {
       "modifiers": modifiers
     });
   }),
 
   sendTouchEvent: defineNoReturnMethod(function(type, identifiers, touchesX, touchesY,
                                                 radiisX, radiisY, rotationAngles, forces,
                                                 count, modifiers) {
 
-    let tabParent = this._frameLoader.tabParent;
-    if (tabParent && tabParent.useAsyncPanZoom) {
-      tabParent.injectTouchEvent(type,
-                                 identifiers,
-                                 touchesX,
-                                 touchesY,
-                                 radiisX,
-                                 radiisY,
-                                 rotationAngles,
-                                 forces,
-                                 count,
-                                 modifiers);
-    } else {
-      let offset = this.getChildProcessOffset();
-      for (var i = 0; i < touchesX.length; i++) {
-        touchesX[i] += offset.x;
-      }
-      for (var i = 0; i < touchesY.length; i++) {
-        touchesY[i] += offset.y;
-      }
-      this._sendAsyncMsg("send-touch-event", {
-        "type": type,
-        "identifiers": identifiers,
-        "touchesX": touchesX,
-        "touchesY": touchesY,
-        "radiisX": radiisX,
-        "radiisY": radiisY,
-        "rotationAngles": rotationAngles,
-        "forces": forces,
-        "count": count,
-        "modifiers": modifiers
-      });
+    let offset = this.getChildProcessOffset();
+    for (var i = 0; i < touchesX.length; i++) {
+      touchesX[i] += offset.x;
+    }
+    for (var i = 0; i < touchesY.length; i++) {
+      touchesY[i] += offset.y;
     }
+    this._sendAsyncMsg("send-touch-event", {
+      "type": type,
+      "identifiers": identifiers,
+      "touchesX": touchesX,
+      "touchesY": touchesY,
+      "radiisX": radiisX,
+      "radiisY": radiisY,
+      "rotationAngles": rotationAngles,
+      "forces": forces,
+      "count": count,
+      "modifiers": modifiers
+    });
   }),
 
   getCanGoBack: defineDOMRequestMethod('get-can-go-back'),
   getCanGoForward: defineDOMRequestMethod('get-can-go-forward'),
   getContentDimensions: defineDOMRequestMethod('get-contentdimensions'),
 
   findAll: defineNoReturnMethod(function(searchString, caseSensitivity) {
     return this._sendAsyncMsg('find-all', {

--- a/dom/canvas/test/webgl-conf/checkout/conformance2/glsl3/array-complex-indexing.html
+++ b/dom/canvas/test/webgl-conf/checkout/conformance2/glsl3/array-complex-indexing.html
@@ -72,27 +72,16 @@ void main() {
 precision mediump float;
 out vec4 color;
 
 void main() {
   float a = (float[3](2.0, 1.0, 0.0))[0];
   color = (a == 2.0) ? vec4(0, 1.0, 0, 1.0) : vec4(1.0, 0, 0, 1.0);
 }
 </script>
-<script id="fshader-sequence-operator" type="x-shader/x-fragment">#version 300 es
-precision mediump float;
-out vec4 color;
-
-void main() {
-  float a[2] = float[2](1.0, 0.0);
-  float b[2] = float[2](2.0, 3.0);
-  float c = (a, b)[0];
-  color = (c == 2.0) ? vec4(0, 1.0, 0, 1.0) : vec4(1.0, 0, 0, 1.0);
-}
-</script>
 <script type="application/javascript">
 "use strict";
 description("Indexing complex array expressions");
 debug("");
 
 GLSLConformanceTester.runRenderTests([
 {
   fShaderId: 'fshader-assignment',
@@ -107,19 +96,13 @@ GLSLConformanceTester.runRenderTests([
   passMsg: 'Test indexing a function return with a side-effect: (functionReturnArray())[0]'
 },
 {
   fShaderId: 'fshader-array-initialization',
   fShaderSuccess: true,
   linkSuccess: true,
   passMsg: 'Test indexing an array initialization: (float[3](2.0, 1.0, 0.0))[0]'
 },
-{
-  fShaderId: 'fshader-sequence-operator',
-  fShaderSuccess: true,
-  linkSuccess: true,
-  passMsg: 'Test indexing a sequence operator: (a, b)[0]'
-},
 ], 2);
 
 </script>
 </body>
 </html>

--- a/dom/events/test/test_bug456273.html
+++ b/dom/events/test/test_bug456273.html
@@ -18,17 +18,17 @@ https://bugzilla.mozilla.org/show_bug.cg
 <div id="edit456273" contenteditable="true">text</div>
 
 <pre id="test">
 <script type="application/javascript">
 
 /** Test for Bug 456273 **/
 
 function doTest() {
-  var ev = document.createEvent('KeyEvents');
+  var ev = document.createEvent('KeyboardEvent');
   ev.initKeyEvent("keypress", true, true, null, true, false,
                  false, false, 0, "z".charCodeAt(0));
   SpecialPowers.dispatchEvent(window, document.getElementById('edit456273'), ev);
 
   ok(true, "PASS");
   SimpleTest.finish();
 }
 

--- a/dom/events/test/test_bug508479.html
+++ b/dom/events/test/test_bug508479.html
@@ -34,25 +34,25 @@ function fireDrop(element, shouldAllowDr
   synthesizeMouse(element, 2, 2, { type: "mousedown" });
   synthesizeMouse(element, 11, 11, { type: "mousemove" });
   synthesizeMouse(element, 20, 20, { type: "mousemove" });
   window.removeEventListener("dragstart", trapDrag, true);
   synthesizeMouse(element, 20, 20, { type: "mouseup" });
 
   ds.startDragSession();
 
-  var event = document.createEvent("DragEvents");
+  var event = document.createEvent("DragEvent");
   event.initDragEvent("dragover", true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null, dataTransfer);
   fireEvent(element, event);
 
   is(ds.getCurrentSession().canDrop, shouldAllowDrop, "Unexpected .canDrop");
   is(ds.getCurrentSession().onlyChromeDrop, shouldAllowOnlyChromeDrop,
      "Unexpected .onlyChromeDrop");
 
-  event = document.createEvent("DragEvents");
+  event = document.createEvent("DragEvent");
   event.initDragEvent("drop", true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null, dataTransfer);
   fireEvent(element, event);
 
   ds.endDragSession(false);
   ok(!ds.getCurrentSession(), "There shouldn't be a drag session anymore!");
 }
 
 var chromeGotEvent = false;

--- a/dom/events/test/test_bug591249.xul
+++ b/dom/events/test/test_bug591249.xul
@@ -55,17 +55,17 @@ function RunTest() {
   // need to use real mouse action to get the dataTransfer
   window.addEventListener("dragstart", trapDrag, true);
   synthesizeMouse(image, 2, 2, { type: "mousedown" });
   synthesizeMouse(image, 11, 11, { type: "mousemove" });
   synthesizeMouse(image, 20, 20, { type: "mousemove" });
   window.removeEventListener("dragstart", trapDrag, true);
   synthesizeMouse(image, 20, 20, { type: "mouseup" });
 
-  var event = document.createEvent("DragEvents");
+  var event = document.createEvent("DragEvent");
   event.initDragEvent("dragover", true, true, iBox.ownerDocument.defaultView, 0, 0, 0, 0, 0, false, false, false, false, 0, iBox, dataTransfer);
   fireEvent(iBox, event);
   synthesizeMouse(image, 3, 3, { type: "mousedown" });
   synthesizeMouse(image, 23, 23, { type: "mousemove" });
   synthesizeMouse(iBox, insideBoxX, insideBoxY, { type: "mousemove" });
   ok(window.getComputedStyle(iBox).backgroundColor == "rgb(255, 255, 0)", "The -moz-drag-over style should be applied.");
   synthesizeMouse(iBox, insideBoxX, insideBoxY, { type: "mouseup" });
   window.setTimeout(function () { completeTest(iBox); }, 40);

--- a/dom/events/test/test_dom_keyboard_event.html
+++ b/dom/events/test/test_dom_keyboard_event.html
@@ -37,32 +37,32 @@ function testInitializingUntrustedEvent(
       ctrlKey: false, altKey: true, shiftKey: false, metaKey: false,
       keyCode: 0x11, charCode: 0x30 },
 
     { createEventArg: "keyboardEvent",
       type: "boo", bubbles: false, cancelable: false, view: window,
       ctrlKey: false, altKey: false, shiftKey: true, metaKey: false,
       keyCode: 0x30, charCode: 0x40 },
 
-    { createEventArg: "KeyEvents",
+    { createEventArg: "KeyBoardEvent",
       type: "foo", bubbles: true, cancelable: true, view: null,
       ctrlKey: false, altKey: false, shiftKey: false, metaKey: true,
       keyCode: 0x00, charCode: 0x50 },
 
-    { createEventArg: "keyevents",
+    { createEventArg: "keyboardevEnt",
       type: "bar", bubbles: false, cancelable: true, view: window,
       ctrlKey: true, altKey: true, shiftKey: false, metaKey: false,
       keyCode: 0x00, charCode: 0x60 },
 
-    { createEventArg: "Keyevents",
+    { createEventArg: "KeyboaRdevent",
       type: "keydown", bubbles: true, cancelable: false, view: null,
       ctrlKey: false, altKey: true, shiftKey: false, metaKey: true,
       keyCode: 0x30, charCode: 0x00 },
 
-    { createEventArg: "keyEvents",
+    { createEventArg: "KEYBOARDEVENT",
       type: "keyup", bubbles: false, cancelable: false, view: window,
       ctrlKey: true, altKey: false, shiftKey: true, metaKey: false,
       keyCode: 0x10, charCode: 0x80 },
 
     { createEventArg: "KeyboardEvent",
       type: "keypress", bubbles: false, cancelable: false, view: window,
       ctrlKey: true, altKey: false, shiftKey: true, metaKey: true,
       keyCode: 0x10, charCode: 0x80 },

--- a/dom/events/test/test_dragstart.html
+++ b/dom/events/test/test_dragstart.html
@@ -52,18 +52,18 @@ function afterDragTests()
 
   var evt = document.createEvent("dragevent");
   ok(evt instanceof DragEvent, "synthetic dragevent class")
   ok(evt instanceof MouseEvent, "synthetic event inherits from MouseEvent")
   evt.initDragEvent("dragstart", true, true, window, 1, 40, 35, 20, 15,
                     false, true, false, false, 0, null, null);
   $("synthetic").dispatchEvent(evt);
 
-  var evt = document.createEvent("dragevents");
-  ok(evt instanceof DragEvent, "synthetic dragevents class")
+  var evt = document.createEvent("dragevent");
+  ok(evt instanceof DragEvent, "synthetic dragevent class")
   evt.initDragEvent("dragover", true, true, window, 0, 40, 35, 20, 15,
                     true, false, true, true, 2, document.documentElement, null);
   $("synthetic2").dispatchEvent(evt);
 
   // next, dragging links and images
   sendMouseEventsForDrag("link");
   sendMouseEventsForDrag("image");
 

--- a/dom/flyweb/FlyWebPublishedServer.cpp
+++ b/dom/flyweb/FlyWebPublishedServer.cpp
@@ -166,16 +166,26 @@ NS_IMPL_ISUPPORTS_INHERITED0(FlyWebPubli
 
 FlyWebPublishedServerImpl::FlyWebPublishedServerImpl(nsPIDOMWindowInner* aOwner,
                                                      const nsAString& aName,
                                                      const FlyWebPublishOptions& aOptions)
   : FlyWebPublishedServer(aOwner, aName, aOptions)
   , mHttpServer(new HttpServer())
 {
   LOG_I("FlyWebPublishedServerImpl::FlyWebPublishedServerImpl(%p)", this);
+}
+
+void
+FlyWebPublishedServerImpl::PermissionGranted(bool aGranted)
+{
+  LOG_I("FlyWebPublishedServerImpl::PermissionGranted(%b)", aGranted);
+  if (!aGranted) {
+    PublishedServerStarted(NS_ERROR_FAILURE);
+    return;
+  }
 
   mHttpServer->Init(-1, Preferences::GetBool("flyweb.use-tls", false), this);
 }
 
 void
 FlyWebPublishedServerImpl::Close()
 {
   FlyWebPublishedServer::Close();
@@ -247,72 +257,84 @@ FlyWebPublishedServerImpl::OnWebSocketAc
 }
 
 /******** FlyWebPublishedServerChild ********/
 
 FlyWebPublishedServerChild::FlyWebPublishedServerChild(nsPIDOMWindowInner* aOwner,
                                                        const nsAString& aName,
                                                        const FlyWebPublishOptions& aOptions)
   : FlyWebPublishedServer(aOwner, aName, aOptions)
-  , mActorDestroyed(false)
+  , mActorExists(false)
 {
   LOG_I("FlyWebPublishedServerChild::FlyWebPublishedServerChild(%p)", this);
 
-  ContentChild::GetSingleton()->
-    SendPFlyWebPublishedServerConstructor(this,
-                                          PromiseFlatString(aName),
-                                          aOptions);
-
   // The matching release happens when the actor is destroyed, in
   // ContentChild::DeallocPFlyWebPublishedServerChild
   NS_ADDREF_THIS();
 }
 
+void
+FlyWebPublishedServerChild::PermissionGranted(bool aGranted)
+{
+  if (!aGranted) {
+    PublishedServerStarted(NS_ERROR_FAILURE);
+    return;
+  }
+
+  mActorExists = true;
+  FlyWebPublishOptions options;
+  options.mUiUrl = mUiUrl;
+
+  // Proceed with initialization.
+  ContentChild::GetSingleton()->
+    SendPFlyWebPublishedServerConstructor(this, mName, options);
+}
+
 bool
 FlyWebPublishedServerChild::RecvServerReady(const nsresult& aStatus)
 {
   LOG_I("FlyWebPublishedServerChild::RecvServerReady(%p)", this);
-  MOZ_ASSERT(!mActorDestroyed);
+  MOZ_ASSERT(mActorExists);
 
   PublishedServerStarted(aStatus);
   return true;
 }
 
 bool
 FlyWebPublishedServerChild::RecvServerClose()
 {
   LOG_I("FlyWebPublishedServerChild::RecvServerClose(%p)", this);
-  MOZ_ASSERT(!mActorDestroyed);
+  MOZ_ASSERT(mActorExists);
 
   Close();
 
   return true;
 }
 
 bool
 FlyWebPublishedServerChild::RecvFetchRequest(const IPCInternalRequest& aRequest,
                                              const uint64_t& aRequestId)
 {
   LOG_I("FlyWebPublishedServerChild::RecvFetchRequest(%p)", this);
-  MOZ_ASSERT(!mActorDestroyed);
+  MOZ_ASSERT(mActorExists);
 
   RefPtr<InternalRequest> request = new InternalRequest(aRequest);
   mPendingRequests.Put(request, aRequestId);
   FireFetchEvent(request);
 
   return true;
 }
 
 bool
 FlyWebPublishedServerChild::RecvWebSocketRequest(const IPCInternalRequest& aRequest,
                                                  const uint64_t& aRequestId,
                                                  PTransportProviderChild* aProvider)
 {
   LOG_I("FlyWebPublishedServerChild::RecvWebSocketRequest(%p)", this);
-  MOZ_ASSERT(!mActorDestroyed);
+  MOZ_ASSERT(mActorExists);
 
   RefPtr<InternalRequest> request = new InternalRequest(aRequest);
   mPendingRequests.Put(request, aRequestId);
 
   // Not addreffing here. The addref was already done when the
   // PTransportProvider child constructor original ran.
   mPendingTransportProviders.Put(aRequestId,
     dont_AddRef(static_cast<TransportProviderChild*>(aProvider)));
@@ -322,26 +344,26 @@ FlyWebPublishedServerChild::RecvWebSocke
   return true;
 }
 
 void
 FlyWebPublishedServerChild::ActorDestroy(ActorDestroyReason aWhy)
 {
   LOG_I("FlyWebPublishedServerChild::ActorDestroy(%p)", this);
 
-  mActorDestroyed = true;
+  mActorExists = false;
 }
 
 void
 FlyWebPublishedServerChild::OnFetchResponse(InternalRequest* aRequest,
                                             InternalResponse* aResponse)
 {
   LOG_I("FlyWebPublishedServerChild::OnFetchResponse(%p)", this);
 
-  if (mActorDestroyed) {
+  if (!mActorExists) {
     LOG_I("FlyWebPublishedServerChild::OnFetchResponse(%p) - No actor!", this);
     return;
   }
 
   uint64_t id = mPendingRequests.Get(aRequest);
   MOZ_ASSERT(id);
   mPendingRequests.Remove(aRequest);
 
@@ -356,17 +378,17 @@ FlyWebPublishedServerChild::OnFetchRespo
 
 already_AddRefed<nsITransportProvider>
 FlyWebPublishedServerChild::OnWebSocketAcceptInternal(InternalRequest* aRequest,
                                                       const Optional<nsAString>& aProtocol,
                                                       ErrorResult& aRv)
 {
   LOG_I("FlyWebPublishedServerChild::OnWebSocketAcceptInternal(%p)", this);
 
-  if (mActorDestroyed) {
+  if (!mActorExists) {
     LOG_I("FlyWebPublishedServerChild::OnWebSocketAcceptInternal(%p) - No actor!", this);
     return nullptr;
   }
 
   uint64_t id = mPendingRequests.Get(aRequest);
   MOZ_ASSERT(id);
   mPendingRequests.Remove(aRequest);
 
@@ -395,17 +417,17 @@ FlyWebPublishedServerChild::OnWebSocketA
 }
 
 void
 FlyWebPublishedServerChild::OnWebSocketResponse(InternalRequest* aRequest,
                                                 InternalResponse* aResponse)
 {
   LOG_I("FlyWebPublishedServerChild::OnFetchResponse(%p)", this);
 
-  if (mActorDestroyed) {
+  if (!mActorExists) {
     LOG_I("FlyWebPublishedServerChild::OnFetchResponse(%p) - No actor!", this);
     return;
   }
 
   uint64_t id = mPendingRequests.Get(aRequest);
   MOZ_ASSERT(id);
   mPendingRequests.Remove(aRequest);
 
@@ -423,17 +445,17 @@ FlyWebPublishedServerChild::OnWebSocketR
 
 void
 FlyWebPublishedServerChild::Close()
 {
   LOG_I("FlyWebPublishedServerChild::Close(%p)", this);
 
   FlyWebPublishedServer::Close();
 
-  if (!mActorDestroyed) {
+  if (mActorExists) {
     LOG_I("FlyWebPublishedServerChild::Close - sending __delete__ (%p)", this);
 
     Send__delete__(this);
   }
 }
 
 /******** FlyWebPublishedServerParent ********/
 

--- a/dom/flyweb/FlyWebPublishedServer.h
+++ b/dom/flyweb/FlyWebPublishedServer.h
@@ -52,16 +52,18 @@ public:
     return mName;
   }
 
   void GetUiUrl(nsAString& aUiUrl)
   {
     aUiUrl = mUiUrl;
   }
 
+  virtual void PermissionGranted(bool aGranted) = 0;
+
   virtual void OnFetchResponse(InternalRequest* aRequest,
                                InternalResponse* aResponse) = 0;
   already_AddRefed<WebSocket>
     OnWebSocketAccept(InternalRequest* aConnectRequest,
                       const Optional<nsAString>& aProtocol,
                       ErrorResult& aRv);
   virtual void OnWebSocketResponse(InternalRequest* aConnectRequest,
                                    InternalResponse* aResponse) = 0;

--- a/dom/flyweb/FlyWebPublishedServerIPC.h
+++ b/dom/flyweb/FlyWebPublishedServerIPC.h
@@ -45,16 +45,17 @@ public:
   void GetCertKey(nsACString& aKey) {
     if (mHttpServer) {
       mHttpServer->GetCertKey(aKey);
     } else {
       aKey.Truncate();
     }
   }
 
+  virtual void PermissionGranted(bool aGranted) override;
   virtual void OnFetchResponse(InternalRequest* aRequest,
                                InternalResponse* aResponse) override;
   virtual void OnWebSocketResponse(InternalRequest* aConnectRequest,
                                    InternalResponse* aResponse) override;
   virtual already_AddRefed<nsITransportProvider>
     OnWebSocketAcceptInternal(InternalRequest* aConnectRequest,
                               const Optional<nsAString>& aProtocol,
                               ErrorResult& aRv) override;
@@ -93,16 +94,17 @@ private:
 class FlyWebPublishedServerChild final : public FlyWebPublishedServer
                                        , public PFlyWebPublishedServerChild
 {
 public:
   FlyWebPublishedServerChild(nsPIDOMWindowInner* aOwner,
                              const nsAString& aName,
                              const FlyWebPublishOptions& aOptions);
 
+  virtual void PermissionGranted(bool aGranted) override;
   virtual bool RecvServerReady(const nsresult& aStatus) override;
   virtual bool RecvServerClose() override;
   virtual bool RecvFetchRequest(const IPCInternalRequest& aRequest,
                                 const uint64_t& aRequestId) override;
   virtual bool RecvWebSocketRequest(const IPCInternalRequest& aRequest,
                                     const uint64_t& aRequestId,
                                     PTransportProviderChild* aProvider) override;
 
@@ -120,17 +122,17 @@ public:
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
 private:
   ~FlyWebPublishedServerChild() {}
 
   nsDataHashtable<nsRefPtrHashKey<InternalRequest>, uint64_t> mPendingRequests;
   nsRefPtrHashtable<nsUint64HashKey, TransportProviderChild>
     mPendingTransportProviders;
-  bool mActorDestroyed;
+  bool mActorExists;
 };
 
 class FlyWebPublishedServerParent final : public PFlyWebPublishedServerParent
                                         , public nsIDOMEventListener
 {
 public:
   FlyWebPublishedServerParent(const nsAString& aName,
                               const FlyWebPublishOptions& aOptions);

--- a/dom/flyweb/FlyWebService.cpp
+++ b/dom/flyweb/FlyWebService.cpp
@@ -4,46 +4,160 @@
  * 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/. */
 
 #include "mozilla/dom/FlyWebService.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/ScopeExit.h"
 #include "mozilla/dom/Promise.h"
 #include "mozilla/dom/FlyWebPublishedServerIPC.h"
+#include "mozilla/AddonPathService.h"
 #include "nsISocketTransportService.h"
 #include "mdns/libmdns/nsDNSServiceInfo.h"
 #include "nsIUUIDGenerator.h"
 #include "nsStandardURL.h"
 #include "mozilla/Services.h"
 #include "nsISupportsPrimitives.h"
 #include "mozilla/dom/FlyWebDiscoveryManagerBinding.h"
 #include "prnetdb.h"
 #include "DNS.h"
+#include "nsContentPermissionHelper.h"
 #include "nsSocketTransportService2.h"
 #include "nsSocketTransport2.h"
 #include "nsHashPropertyBag.h"
 #include "nsNetUtil.h"
 #include "nsISimpleEnumerator.h"
 #include "nsIProperty.h"
 #include "nsICertOverrideService.h"
 
 namespace mozilla {
 namespace dom {
 
 struct FlyWebPublishOptions;
 
 static LazyLogModule gFlyWebServiceLog("FlyWebService");
 #undef LOG_I
 #define LOG_I(...) MOZ_LOG(mozilla::dom::gFlyWebServiceLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
+
 #undef LOG_E
 #define LOG_E(...) MOZ_LOG(mozilla::dom::gFlyWebServiceLog, mozilla::LogLevel::Error, (__VA_ARGS__))
+
 #undef LOG_TEST_I
 #define LOG_TEST_I(...) MOZ_LOG_TEST(mozilla::dom::gFlyWebServiceLog, mozilla::LogLevel::Debug)
 
+class FlyWebPublishServerPermissionCheck final
+  : public nsIContentPermissionRequest
+  , public nsIRunnable
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  FlyWebPublishServerPermissionCheck(const nsCString& aServiceName, uint64_t aWindowID,
+                                     FlyWebPublishedServer* aServer)
+    : mServiceName(aServiceName)
+    , mWindowID(aWindowID)
+    , mServer(aServer)
+  {}
+
+  uint64_t WindowID() const
+  {
+    return mWindowID;
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    nsGlobalWindow* globalWindow = nsGlobalWindow::GetInnerWindowWithId(mWindowID);
+    if (!globalWindow) {
+      return Cancel();
+    }
+    mWindow = globalWindow->AsInner();
+    if (NS_WARN_IF(!mWindow)) {
+      return Cancel();
+    }
+
+    nsCOMPtr<nsIDocument> doc = mWindow->GetDoc();
+    if (NS_WARN_IF(!doc)) {
+      return Cancel();
+    }
+
+    mPrincipal = doc->NodePrincipal();
+    MOZ_ASSERT(mPrincipal);
+
+    mRequester = new nsContentPermissionRequester(mWindow);
+    return nsContentPermissionUtils::AskPermission(this, mWindow);
+  }
+
+  NS_IMETHOD Cancel() override
+  {
+    Resolve(false);
+    return NS_OK;
+  }
+
+  NS_IMETHOD Allow(JS::HandleValue aChoices) override
+  {
+    MOZ_ASSERT(aChoices.isUndefined());
+    Resolve(true);
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetTypes(nsIArray** aTypes) override
+  {
+    nsTArray<nsString> emptyOptions;
+    return nsContentPermissionUtils::CreatePermissionArray(NS_LITERAL_CSTRING("flyweb-publish-server"),
+                                                           NS_LITERAL_CSTRING("unused"), emptyOptions, aTypes);
+  }
+
+  NS_IMETHOD GetRequester(nsIContentPermissionRequester** aRequester) override
+  {
+    NS_ENSURE_ARG_POINTER(aRequester);
+    nsCOMPtr<nsIContentPermissionRequester> requester = mRequester;
+    requester.forget(aRequester);
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetPrincipal(nsIPrincipal** aRequestingPrincipal) override
+  {
+    NS_IF_ADDREF(*aRequestingPrincipal = mPrincipal);
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetWindow(mozIDOMWindow** aRequestingWindow) override
+  {
+    NS_IF_ADDREF(*aRequestingWindow = mWindow);
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetElement(nsIDOMElement** aRequestingElement) override
+  {
+    *aRequestingElement = nullptr;
+    return NS_OK;
+  }
+
+private:
+  void Resolve(bool aResolve)
+  {
+    mServer->PermissionGranted(aResolve);
+  }
+
+  virtual ~FlyWebPublishServerPermissionCheck() = default;
+
+  nsCString mServiceName;
+  uint64_t mWindowID;
+  RefPtr<FlyWebPublishedServer> mServer;
+  nsCOMPtr<nsPIDOMWindowInner> mWindow;
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+  nsCOMPtr<nsIContentPermissionRequester> mRequester;
+};
+
+NS_IMPL_ISUPPORTS(FlyWebPublishServerPermissionCheck,
+                  nsIContentPermissionRequest,
+                  nsIRunnable)
+
 class FlyWebMDNSService final
   : public nsIDNSServiceDiscoveryListener
   , public nsIDNSServiceResolveListener
   , public nsIDNSRegistrationListener
   , public nsITimerCallback
 {
   friend class FlyWebService;
 
@@ -836,39 +950,88 @@ FlyWebService::Init()
       mMDNSFlywebService = nullptr;
       rv.SuppressException();
     }
   }
 
   return ErrorResult(NS_OK);
 }
 
+static already_AddRefed<FlyWebPublishPromise>
+MakeRejectionPromise(const char* name)
+{
+    MozPromiseHolder<FlyWebPublishPromise> holder;
+    RefPtr<FlyWebPublishPromise> promise = holder.Ensure(name);
+    holder.Reject(NS_ERROR_FAILURE, name);
+    return promise.forget();
+}
+
 already_AddRefed<FlyWebPublishPromise>
 FlyWebService::PublishServer(const nsAString& aName,
                              const FlyWebPublishOptions& aOptions,
                              nsPIDOMWindowInner* aWindow)
 {
   // Scan uiUrl for illegal characters
 
   RefPtr<FlyWebPublishedServer> existingServer =
     FlyWebService::GetOrCreate()->FindPublishedServerByName(aName);
   if (existingServer) {
     LOG_I("PublishServer: Trying to publish server with already-existing name %s.",
           NS_ConvertUTF16toUTF8(aName).get());
-    MozPromiseHolder<FlyWebPublishPromise> holder;
-    RefPtr<FlyWebPublishPromise> promise = holder.Ensure(__func__);
-    holder.Reject(NS_ERROR_FAILURE, __func__);
-    return promise.forget();
+    return MakeRejectionPromise(__func__);
   }
 
   RefPtr<FlyWebPublishedServer> server;
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
     server = new FlyWebPublishedServerChild(aWindow, aName, aOptions);
   } else {
     server = new FlyWebPublishedServerImpl(aWindow, aName, aOptions);
+
+    // Before proceeding, ensure that the FlyWeb system addon exists.
+    nsresult rv;
+    nsCOMPtr<nsIURI> uri;
+    rv = NS_NewURI(getter_AddRefs(uri), NS_LITERAL_CSTRING("chrome://flyweb/skin/icon-64.png"));
+    if (NS_FAILED(rv)) {
+      return MakeRejectionPromise(__func__);
+    }
+
+    JSAddonId *addonId = MapURIToAddonID(uri);
+    if (!addonId) {
+      LOG_E("PublishServer: Failed to find FlyWeb system addon.");
+      return MakeRejectionPromise(__func__);
+    }
+
+    JSFlatString* flat = JS_ASSERT_STRING_IS_FLAT(JS::StringOfAddonId(addonId));
+    nsAutoString addonIdString;
+    AssignJSFlatString(addonIdString, flat);
+    if (!addonIdString.EqualsLiteral("flyweb@mozilla.org")) {
+      nsCString addonIdCString = NS_ConvertUTF16toUTF8(addonIdString);
+      LOG_E("PublishServer: FlyWeb resource found on wrong system addon: %s.", addonIdCString.get());
+      return MakeRejectionPromise(__func__);
+    }
+  }
+
+  if (aWindow) {
+    nsresult rv;
+
+    MOZ_ASSERT(NS_IsMainThread());
+    rv = NS_DispatchToCurrentThread(
+      MakeAndAddRef<FlyWebPublishServerPermissionCheck>(
+        NS_ConvertUTF16toUTF8(aName), aWindow->WindowID(), server));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      LOG_E("PublishServer: Failed to dispatch permission check runnable for %s",
+            NS_ConvertUTF16toUTF8(aName).get());
+      return MakeRejectionPromise(__func__);
+    }
+  } else {
+    // If aWindow is null, we're definitely in the e10s parent process.
+    // In this case, we know that permission has already been granted
+    // by the user because of content-process prompt.
+    MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
+    server->PermissionGranted(true);
   }
 
   mServers.AppendElement(server);
 
   return server->GetPublishPromise();
 }
 
 already_AddRefed<FlyWebPublishedServer>

--- a/dom/html/HTMLFormElement.cpp
+++ b/dom/html/HTMLFormElement.cpp
@@ -1532,17 +1532,17 @@ HTMLFormElement::NamedGetter(const nsASt
 
   aFound = false;
   return nullptr;
 }
 
 void
 HTMLFormElement::GetSupportedNames(nsTArray<nsString >& aRetval)
 {
-  // TODO https://www.w3.org/Bugs/Public/show_bug.cgi?id=22320
+  // TODO https://github.com/whatwg/html/issues/1731
 }
 
 already_AddRefed<nsISupports>
 HTMLFormElement::FindNamedItem(const nsAString& aName,
                                nsWrapperCache** aCache)
 {
   // FIXME Get the wrapper cache from DoResolveName.
 

--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -3284,17 +3284,17 @@ HTMLInputElement::GetRadioGroupContainer
     return mForm;
   }
 
   //XXXsmaug It isn't clear how this should work in Shadow DOM.
   return static_cast<nsDocument*>(GetUncomposedDoc());
 }
 
 already_AddRefed<nsIDOMHTMLInputElement>
-HTMLInputElement::GetSelectedRadioButton()
+HTMLInputElement::GetSelectedRadioButton() const
 {
   nsIRadioGroupContainer* container = GetRadioGroupContainer();
   if (!container) {
     return nullptr;
   }
 
   nsAutoString name;
   GetAttr(kNameSpaceID_None, nsGkAtoms::name, name);
@@ -3355,16 +3355,23 @@ HTMLInputElement::SetCheckedInternal(boo
     }
   }
 
   UpdateAllValidityStates(aNotify);
 
   // Notify the document that the CSS :checked pseudoclass for this element
   // has changed state.
   UpdateState(aNotify);
+
+  // Notify all radios in the group that value has changed, this is to let
+  // radios to have the chance to update its states, e.g., :indeterminate.
+  if (mType == NS_FORM_INPUT_RADIO) {
+    nsCOMPtr<nsIRadioVisitor> visitor = new nsRadioUpdateStateVisitor(this);
+    VisitGroup(visitor, aNotify);
+  }
 }
 
 void
 HTMLInputElement::Blur(ErrorResult& aError)
 {
   if (mType == NS_FORM_INPUT_NUMBER) {
     // Blur our anonymous text control, if we have one. (DOM 'change' event
     // firing and other things depend on this.)
@@ -6415,16 +6422,25 @@ HTMLInputElement::IntrinsicState() const
       state |= NS_EVENT_STATE_CHECKED;
     }
 
     // Check current indeterminate state (:indeterminate)
     if (mType == NS_FORM_INPUT_CHECKBOX && mIndeterminate) {
       state |= NS_EVENT_STATE_INDETERMINATE;
     }
 
+    if (mType == NS_FORM_INPUT_RADIO) {
+      nsCOMPtr<nsIDOMHTMLInputElement> selected = GetSelectedRadioButton();
+      bool indeterminate = !selected && !mChecked;
+
+      if (indeterminate) {
+        state |= NS_EVENT_STATE_INDETERMINATE;
+      }
+    }
+
     // Check whether we are the default checked element (:default)
     if (DefaultChecked()) {
       state |= NS_EVENT_STATE_DEFAULT;
     }
   } else if (mType == NS_FORM_INPUT_IMAGE) {
     state |= nsImageLoadingContent::ImageState();
   }
 
@@ -6638,16 +6654,19 @@ HTMLInputElement::WillRemoveFromRadioGro
 
   nsAutoString name;
   GetAttr(kNameSpaceID_None, nsGkAtoms::name, name);
 
   // If this button was checked, we need to notify the group that there is no
   // longer a selected radio button
   if (mChecked) {
     container->SetCurrentRadioButton(name, nullptr);
+
+    nsCOMPtr<nsIRadioVisitor> visitor = new nsRadioUpdateStateVisitor(this);
+    VisitGroup(visitor, true);
   }
 
   // Remove this radio from its group in the container.
   // We need to call UpdateValueMissingValidityStateForRadio before to make sure
   // the group validity is updated (with this element being ignored).
   UpdateValueMissingValidityStateForRadio(true);
   container->RemoveFromRadioGroup(name, static_cast<nsIFormControl*>(this));
 }

--- a/dom/html/HTMLInputElement.h
+++ b/dom/html/HTMLInputElement.h
@@ -259,17 +259,17 @@ public:
 
  /**
    * Helper function returning the currently selected button in the radio group.
    * Returning null if the element is not a button or if there is no selectied
    * button in the group.
    *
    * @return the selected button (or null).
    */
-  already_AddRefed<nsIDOMHTMLInputElement> GetSelectedRadioButton();
+  already_AddRefed<nsIDOMHTMLInputElement> GetSelectedRadioButton() const;
 
   virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const override;
 
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(HTMLInputElement,
                                            nsGenericHTMLFormElementWithState)
 
   static UploadLastDir* gUploadLastDir;
   // create and destroy the static UploadLastDir object for remembering

--- a/dom/html/nsRadioVisitor.cpp
+++ b/dom/html/nsRadioVisitor.cpp
@@ -50,8 +50,20 @@ nsRadioSetValueMissingState::Visit(nsIFo
   input->SetValidityState(nsIConstraintValidation::VALIDITY_STATE_VALUE_MISSING,
                           mValidity);
 
   input->UpdateState(true);
 
   return true;
 }
 
+bool
+nsRadioUpdateStateVisitor::Visit(nsIFormControl* aRadio)
+{
+  if (aRadio == mExcludeElement) {
+    return true;
+  }
+
+  HTMLInputElement* input = static_cast<HTMLInputElement*>(aRadio);
+  input->UpdateState(true);
+
+  return true;
+}
\ No newline at end of file

--- a/dom/html/nsRadioVisitor.h
+++ b/dom/html/nsRadioVisitor.h
@@ -89,10 +89,23 @@ public:
   virtual bool Visit(nsIFormControl* aRadio) override;
 
 protected:
   nsIFormControl* mExcludeElement;
   bool mValidity;
   bool mNotify;
 };
 
+class nsRadioUpdateStateVisitor : public nsRadioVisitor
+{
+public:
+  explicit nsRadioUpdateStateVisitor(nsIFormControl* aExcludeElement)
+    : mExcludeElement(aExcludeElement)
+    { }
+
+  virtual bool Visit(nsIFormControl* aRadio) override;
+
+protected:
+  nsIFormControl* mExcludeElement;
+};
+
 #endif // _nsRadioVisitor_h__
 

--- a/dom/html/reftests/autofocus/reftest.list
+++ b/dom/html/reftests/autofocus/reftest.list
@@ -1,13 +1,13 @@
 default-preferences pref(dom.forms.number,true)
 skip-if(B2G||Mulet) fuzzy-if(skiaContent,1,3) needs-focus == input-load.html input-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
 skip-if(B2G||Mulet) fuzzy-if(skiaContent,1,3) needs-focus == input-create.html input-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
 skip-if(B2G||Mulet) fuzzy-if(skiaContent,1,3) needs-focus == input-number.html input-number-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
 skip-if(B2G||Mulet) fuzzy-if(skiaContent,1,3) needs-focus == button-load.html button-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
 skip-if(B2G||Mulet) fuzzy-if(skiaContent,1,3) needs-focus == button-create.html button-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
 skip-if(B2G||Mulet) fuzzy-if(skiaContent,1,3) needs-focus == textarea-load.html textarea-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
 skip-if(B2G||Mulet) fuzzy-if(skiaContent,1,3) needs-focus == textarea-create.html textarea-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
-skip-if(B2G||Mulet) fuzzy-if(skiaContent,2,4) needs-focus == select-load.html select-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
+skip-if(B2G||Mulet) fuzzy-if(skiaContent,9,6) needs-focus == select-load.html select-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
 skip-if(B2G||Mulet) fuzzy-if(skiaContent,2,4) needs-focus == select-create.html select-ref.html # B2G timed out waiting for reftest-wait to be removed # Initial mulet triage: parity with B2G/B2G Desktop
 needs-focus == autofocus-after-load.html autofocus-after-load-ref.html
 fails-if(B2G||Mulet) fuzzy-if(skiaContent,2,5) needs-focus == autofocus-leaves-iframe.html autofocus-leaves-iframe-ref.html # B2G focus difference between test and reference # Initial mulet triage: parity with B2G/B2G Desktop
 skip-if(B2G||Mulet) fuzzy-if(skiaContent,2,5) needs-focus == autofocus-after-body-focus.html autofocus-after-body-focus-ref.html # bug 773482 # Initial mulet triage: parity with B2G/B2G Desktop

--- a/dom/html/test/file_fullscreen-api-keys.html
+++ b/dom/html/test/file_fullscreen-api-keys.html
@@ -4,29 +4,29 @@
   <meta charset="UTF-8">
 </head>
 <body>
 <script>
 window.addEventListener("Test:DispatchKeyEvents", aEvent => {
   var keyCode = KeyEvent["DOM_" + aEvent.detail.code];
 
   document.body.focus();
-  var evt = document.createEvent("KeyEvents");
+  var evt = document.createEvent("KeyboardEvent");
   evt.initKeyEvent("keydown", true, true, window,
                    false, false, false, false,
                    keyCode, 0);
   document.body.dispatchEvent(evt);
 
-  evt = document.createEvent("KeyEvents");
+  evt = document.createEvent("KeyboardEvent");
   evt.initKeyEvent("keypress", true, true, window,
                    false, false, false, false,
                    keyCode, 0);
   document.body.dispatchEvent(evt);
 
-  evt = document.createEvent("KeyEvents");
+  evt = document.createEvent("KeyboardEvent");
   evt.initKeyEvent("keyup", true, true, window,
                    false, false, false, false,
                    keyCode, 0);
   document.body.dispatchEvent(evt);
 });
 </script>
 </body>
 </html>

--- a/dom/html/test/forms/mochitest.ini
+++ b/dom/html/test/forms/mochitest.ini
@@ -4,16 +4,17 @@ support-files =
   test_input_number_data.js
   !/dom/html/test/reflect.js
 
 [test_bug1039548.html]
 [test_bug1283915.html]
 [test_bug1286509.html]
 skip-if = os == "android" || appname == "b2g" # up/down arrow keys not supported on android/b2g
 [test_button_attributes_reflection.html]
+[test_input_radio_indeterminate.html]
 [test_input_radio_radiogroup.html]
 [test_input_radio_required.html]
 [test_change_event.html]
 skip-if = (buildapp == 'b2g' && toolkit != 'gonk') #Bug 931116, b2g desktop specific, initial triage
 [test_datalist_element.html]
 [test_form_attribute-1.html]
 [test_form_attribute-2.html]
 [test_form_attribute-3.html]

new file mode 100644
--- /dev/null
+++ b/dom/html/test/forms/test_input_radio_indeterminate.html
@@ -0,0 +1,109 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=885359
+-->
+<head>
+  <title>Test for Bug 885359</title>
+  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=885359">Mozilla Bug 343444</a>
+<p id="display"></p>
+<form>
+  <input type="radio" id='radio1'/><br/>
+
+  <input type="radio" id="g1radio1" name="group1"/>
+  <input type="radio" id="g1radio2" name="group1"/></br>
+  <input type="radio" id="g1radio3" name="group1"/></br>
+
+  <input type="radio" id="g2radio1" name="group2"/>
+  <input type="radio" id="g2radio2" name="group2" checked/></br>
+</form>
+<script class="testbody" type="text/javascript">
+
+SimpleTest.waitForExplicitFinish();
+
+var radio1 = document.getElementById("radio1");
+var g1radio1 = document.getElementById("g1radio1");
+var g1radio2 = document.getElementById("g1radio2");
+var g1radio3 = document.getElementById("g1radio3");
+var g2radio1 = document.getElementById("g2radio1");
+var g2radio2 = document.getElementById("g2radio2");
+
+SimpleTest.waitForFocus(function() {
+  test();
+  SimpleTest.finish();
+});
+
+function verifyIndeterminateState(aElement, aIsIndeterminate, aMessage) {
+  is(aElement.mozMatchesSelector(':indeterminate'), aIsIndeterminate, aMessage);
+}
+
+function test() {
+  // Initial State.
+  verifyIndeterminateState(radio1, true,
+    "Unchecked radio in its own group (no name attribute)");
+  verifyIndeterminateState(g1radio1, true, "No selected radio in its group");
+  verifyIndeterminateState(g1radio2, true, "No selected radio in its group");
+  verifyIndeterminateState(g1radio3, true, "No selected radio in its group");
+  verifyIndeterminateState(g2radio1, false, "Selected radio in its group");
+  verifyIndeterminateState(g2radio2, false, "Selected radio in its group");
+
+  // Selecting radio buttion.
+  g1radio1.checked = true;
+  verifyIndeterminateState(g1radio1, false,
+    "Selecting a radio should affect all radios in the group");
+  verifyIndeterminateState(g1radio2, false,
+    "Selecting a radio should affect all radios in the group");
+  verifyIndeterminateState(g1radio3, false,
+    "Selecting a radio should affect all radios in the group");
+
+  // Changing the selected radio button.
+  g1radio3.checked = true;
+  verifyIndeterminateState(g1radio1, false,
+    "Selecting a radio should affect all radios in the group");
+  verifyIndeterminateState(g1radio2, false,
+    "Selecting a radio should affect all radios in the group");
+  verifyIndeterminateState(g1radio3, false,
+    "Selecting a radio should affect all radios in the group");
+
+  // Deselecting radio button.
+  g2radio2.checked = false;
+  verifyIndeterminateState(g2radio1, true,
+    "Deselecting a radio should affect all radios in the group");
+  verifyIndeterminateState(g2radio2, true,
+    "Deselecting a radio should affect all radios in the group");
+
+  // Move a selected radio button to another group.
+  g1radio3.name = "group2";
+
+  // The radios' state in the original group becomes indeterminated.
+  verifyIndeterminateState(g1radio1, true,
+    "Removing a radio from a group should affect all radios in the group");
+  verifyIndeterminateState(g1radio2, true,
+    "Removing a radio from a group should affect all radios in the group");
+
+  // The radios' state in the new group becomes determinated.
+  verifyIndeterminateState(g1radio3, false,
+    "Adding a radio from a group should affect all radios in the group");
+  verifyIndeterminateState(g2radio1, false,
+    "Adding a radio from a group should affect all radios in the group");
+  verifyIndeterminateState(g2radio2, false,
+    "Adding a radio from a group should affect all radios in the group");
+
+  // Change input type to 'text'.
+  g1radio3.type = "text";
+  verifyIndeterminateState(g1radio3, false,
+    "Input type text does not have an indeterminate state");
+  verifyIndeterminateState(g2radio1, true,
+    "Changing input type should affect all radios in the group");
+  verifyIndeterminateState(g2radio2, true,
+    "Changing input type should affect all radios in the group");
+}
+</script>
+</pre>
+</body>
+</html>
+

--- a/dom/interfaces/base/nsITabParent.idl
+++ b/dom/interfaces/base/nsITabParent.idl
@@ -3,27 +3,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 
 #include "domstubs.idl"
 
 [builtinclass, scriptable, uuid(8e49f7b0-1f98-4939-bf91-e9c39cd56434)]
 interface nsITabParent : nsISupports
 {
-  void injectTouchEvent(in AString aType,
-                        [array, size_is(count)] in uint32_t aIdentifiers,
-                        [array, size_is(count)] in int32_t aXs,
-                        [array, size_is(count)] in int32_t aYs,
-                        [array, size_is(count)] in uint32_t aRxs,
-                        [array, size_is(count)] in uint32_t aRys,
-                        [array, size_is(count)] in float aRotationAngles,
-                        [array, size_is(count)] in float aForces,
-                        in uint32_t count,
-                        in long aModifiers);
-
   void getChildProcessOffset(out int32_t aCssX, out int32_t aCssY);
 
   readonly attribute boolean useAsyncPanZoom;
 
   /**
     * Manages the docshell active state of the remote browser.
     */
   attribute boolean docShellIsActive;

--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -27,17 +27,16 @@
 #include "mozilla/dom/ContentParent.h"
 #include "mozilla/dom/DataTransfer.h"
 #include "mozilla/dom/DOMStorageIPC.h"
 #include "mozilla/dom/ExternalHelperAppChild.h"
 #include "mozilla/dom/FlyWebPublishedServerIPC.h"
 #include "mozilla/dom/GetFilesHelper.h"
 #include "mozilla/dom/PCrashReporterChild.h"
 #include "mozilla/dom/ProcessGlobal.h"
-#include "mozilla/dom/Promise.h"
 #include "mozilla/dom/workers/ServiceWorkerManager.h"
 #include "mozilla/dom/nsIContentChild.h"
 #include "mozilla/gfx/gfxVars.h"
 #include "mozilla/psm/PSMContentListener.h"
 #include "mozilla/hal_sandbox/PHalChild.h"
 #include "mozilla/ipc/BackgroundChild.h"
 #include "mozilla/ipc/FileDescriptorSetChild.h"
 #include "mozilla/ipc/FileDescriptorUtils.h"
@@ -2258,32 +2257,16 @@ nsresult
 ContentChild::AddRemoteAlertObserver(const nsString& aData,
                                      nsIObserver* aObserver)
 {
   NS_ASSERTION(aObserver, "Adding a null observer?");
   mAlertObservers.AppendElement(new AlertObserver(aObserver, aData));
   return NS_OK;
 }
 
-
-bool
-ContentChild::RecvSystemMemoryAvailable(const uint64_t& aGetterId,
-                                        const uint32_t& aMemoryAvailable)
-{
-  RefPtr<Promise> p = dont_AddRef(reinterpret_cast<Promise*>(aGetterId));
-
-  if (!aMemoryAvailable) {
-    p->MaybeReject(NS_ERROR_NOT_AVAILABLE);
-    return true;
-  }
-
-  p->MaybeResolve((int)aMemoryAvailable);
-  return true;
-}
-
 bool
 ContentChild::RecvPreferenceUpdate(const PrefSetting& aPref)
 {
   Preferences::SetPreference(aPref);
   return true;
 }
 
 bool

--- a/dom/ipc/ContentChild.h
+++ b/dom/ipc/ContentChild.h
@@ -399,19 +399,16 @@ public:
   virtual bool RecvBidiKeyboardNotify(const bool& isLangRTL,
                                       const bool& haveBidiKeyboards) override;
 
   virtual bool RecvNotifyVisited(const URIParams& aURI) override;
 
   // auto remove when alertfinished is received.
   nsresult AddRemoteAlertObserver(const nsString& aData, nsIObserver* aObserver);
 
-  virtual bool RecvSystemMemoryAvailable(const uint64_t& aGetterId,
-                                         const uint32_t& aMemoryAvailable) override;
-
   virtual bool RecvPreferenceUpdate(const PrefSetting& aPref) override;
   virtual bool RecvVarUpdate(const GfxVarUpdate& pref) override;
 
   virtual bool RecvDataStoragePut(const nsString& aFilename,
                                   const DataStorageItem& aItem) override;
 
   virtual bool RecvDataStorageRemove(const nsString& aFilename,
                                      const nsCString& aKey,