--- a/accessible/base/ARIAMap.cpp
+++ b/accessible/base/ARIAMap.cpp
@@ -136,17 +136,17 @@ static const nsRoleMapEntry sWAIRoleMaps
   { // combobox
     &nsGkAtoms::combobox,
     roles::COMBOBOX,
     kUseMapRole,
     eNoValue,
     eOpenCloseAction,
     eNoLiveAttr,
     kGenericAccType,
-    states::COLLAPSED | states::HASPOPUP | states::VERTICAL,
+    states::COLLAPSED | states::HASPOPUP,
     eARIAAutoComplete,
     eARIAReadonly,
     eARIAOrientation
   },
   { // complementary
     &nsGkAtoms::complementary,
     roles::NOTHING,
     kUseNativeRole,
@@ -783,40 +783,41 @@ static const nsRoleMapEntry sWAIRoleMaps
   { // menuitem
     &nsGkAtoms::menuitem,
     roles::MENUITEM,
     kUseMapRole,
     eNoValue,
     eClickAction,
     eNoLiveAttr,
     kGenericAccType,
-    kNoReqStates,
-    eARIACheckedMixed
+    kNoReqStates
   },
   { // menuitemcheckbox
     &nsGkAtoms::menuitemcheckbox,
     roles::CHECK_MENU_ITEM,
     kUseMapRole,
     eNoValue,
     eClickAction,
     eNoLiveAttr,
     kGenericAccType,
     kNoReqStates,
-    eARIACheckableMixed
+    eARIACheckableMixed,
+    eARIAReadonly
   },
   { // menuitemradio
     &nsGkAtoms::menuitemradio,
     roles::RADIO_MENU_ITEM,
     kUseMapRole,
     eNoValue,
     eClickAction,
     eNoLiveAttr,
     kGenericAccType,
     kNoReqStates,
-    eARIACheckableBool
+    eARIACheckableBool,
+    eARIAReadonly
   },
   { // navigation
     &nsGkAtoms::navigation,
     roles::NOTHING,
     kUseNativeRole,
     eNoValue,
     eNoAction,
     eNoLiveAttr,
@@ -891,17 +892,18 @@ static const nsRoleMapEntry sWAIRoleMaps
     &nsGkAtoms::radiogroup,
     roles::RADIO_GROUP,
     kUseMapRole,
     eNoValue,
     eNoAction,
     eNoLiveAttr,
     kGenericAccType,
     kNoReqStates,
-    eARIAOrientation
+    eARIAOrientation,
+    eARIAReadonly
   },
   { // region
     &nsGkAtoms::region,
     roles::PANE,
     kUseMapRole,
     eNoValue,
     eNoAction,
     eNoLiveAttr,
@@ -1024,17 +1026,18 @@ static const nsRoleMapEntry sWAIRoleMaps
     &nsGkAtoms::_switch,
     roles::SWITCH,
     kUseMapRole,
     eNoValue,
     eCheckUncheckAction,
     eNoLiveAttr,
     kGenericAccType,
     kNoReqStates,
-    eARIACheckableBool
+    eARIACheckableBool,
+    eARIAReadonly
   },
   { // tab
     &nsGkAtoms::tab,
     roles::PAGETAB,
     kUseMapRole,
     eNoValue,
     eSwitchAction,
     eNoLiveAttr,
@@ -1144,17 +1147,17 @@ static const nsRoleMapEntry sWAIRoleMaps
   { // treegrid
     &nsGkAtoms::treegrid,
     roles::TREE_TABLE,
     kUseMapRole,
     eNoValue,
     eNoAction,
     eNoLiveAttr,
     eSelect | eTable,
-    states::VERTICAL,
+    kNoReqStates,
     eARIAReadonlyOrEditable,
     eARIAMultiSelectable,
     eFocusableUntilDisabled,
     eARIAOrientation
   },
   { // treeitem
     &nsGkAtoms::treeitem,
     roles::OUTLINEITEM,

--- a/accessible/ipc/win/HandlerProvider.h
+++ b/accessible/ipc/win/HandlerProvider.h
@@ -59,17 +59,17 @@ private:
                                      mscom::ProxyUniquePtr<IHandlerControl> aCtrl);
   void GetAndSerializePayload(const MutexAutoLock&);
   void BuildIA2Data(IA2Data* aOutIA2Data);
   static void ClearIA2Data(IA2Data& aData);
   bool IsTargetInterfaceCacheable();
 
   Atomic<uint32_t>                  mRefCnt;
   Mutex                             mMutex; // Protects mSerializer
-  REFIID                            mTargetUnkIid;
+  const IID                         mTargetUnkIid;
   mscom::InterceptorTargetPtr<IUnknown> mTargetUnk; // Constant, main thread only
   UniquePtr<mscom::StructToStream>  mSerializer;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif // mozilla_a11y_HandlerProvider_h

--- a/accessible/tests/mochitest/attributes/test_obj.html
+++ b/accessible/tests/mochitest/attributes/test_obj.html
@@ -25,17 +25,19 @@ https://bugzilla.mozilla.org/show_bug.cg
       testAttrs("atomic", {"atomic" : "true", "container-atomic" : "true"}, true);
       testAttrs(getNode("atomic").firstChild, {"container-atomic" : "true"}, true);
       testAbsentAttrs("atomic_false", {"atomic" : "false", "container-atomic" : "false"});
       testAbsentAttrs(getNode("atomic_false").firstChild, {"container-atomic" : "false"});
 
       testAttrs("autocomplete", {"autocomplete" : "true"}, true);
       testAttrs("checkbox", {"checkable" : "true"}, true);
       testAttrs("checkedCheckbox", {"checkable" : "true"}, true);
-      testAttrs("checkedMenuitem", {"checkable" : "true"}, true);
+      testAbsentAttrs("checkedMenuitem", {"checkable" : "true"}, true);
+      testAttrs("checkedMenuitemCheckbox", {"checkable" : "true"}, true);
+      testAttrs("checkedMenuitemRadio", {"checkable" : "true"}, true);
       testAttrs("checkedOption", {"checkable" : "true"}, true);
       testAttrs("checkedRadio", {"checkable" : "true"}, true);
       testAttrs("checkedTreeitem", {"checkable" : "true"}, true);
       testAttrs("dropeffect", {"dropeffect" : "copy"}, true);
       testAttrs("grabbed", {"grabbed" : "true"}, true);
       testAbsentAttrs("haspopup", { "haspopup": "false" });
       testAttrs("hidden", {"hidden" : "true"}, true);
       testAbsentAttrs("hidden_false", { "hidden": "false" });
@@ -200,16 +202,18 @@ https://bugzilla.mozilla.org/show_bug.cg
 
   <!-- aria -->
   <div id="atomic" aria-atomic="true">live region</div>
   <div id="atomic_false" aria-atomic="false">live region</div>
   <div id="autocomplete" role="textbox" aria-autocomplete="true"></div>
   <div id="checkbox" role="checkbox"></div>
   <div id="checkedCheckbox" role="checkbox" aria-checked="true"></div>
   <div id="checkedMenuitem" role="menuitem" aria-checked="true"></div>
+  <div id="checkedMenuitemCheckbox" role="menuitemcheckbox" aria-checked="true"></div>
+  <div id="checkedMenuitemRadio" role="menuitemradio" aria-checked="true"></div>
   <div id="checkedOption" role="option" aria-checked="true"></div>
   <div id="checkedRadio" role="radio" aria-checked="true"></div>
   <div id="checkedTreeitem" role="treeitem" aria-checked="true"></div>
   <div id="dropeffect" aria-dropeffect="copy"></div>
   <div id="grabbed" aria-grabbed="true"></div>
   <div id="haspopup" aria-haspopup="true"></div>
   <div id="hidden" aria-hidden="true"></div>
   <div id="hidden_false" aria-hidden="false"></div>

--- a/accessible/tests/mochitest/states/test_aria.html
+++ b/accessible/tests/mochitest/states/test_aria.html
@@ -218,17 +218,17 @@
 
       // some weak landmarks
       testStates("aria_main_link", STATE_LINKED);
       testStates("aria_navigation_link", STATE_LINKED);
       testStates("aria_main_anchor", STATE_SELECTABLE);
       testStates("aria_navigation_anchor", STATE_SELECTABLE);
 
       // aria-orientation
-      testStates("aria_combobox", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
+      testStates("aria_combobox", 0, 0, 0, EXT_STATE_HORIZONTAL | EXT_STATE_VERTICAL);
       testStates("aria_hcombobox", 0, EXT_STATE_HORIZONTAL, 0, EXT_STATE_VERTICAL);
       testStates("aria_vcombobox", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
       testStates("aria_listbox", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
       testStates("aria_hlistbox", 0, EXT_STATE_HORIZONTAL, 0, EXT_STATE_VERTICAL);
       testStates("aria_vlistbox", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
       testStates("aria_menu", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
       testStates("aria_hmenu", 0, EXT_STATE_HORIZONTAL, 0, EXT_STATE_VERTICAL);
       testStates("aria_vmenu", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
@@ -251,17 +251,17 @@
       testStates("aria_htablist", 0, EXT_STATE_HORIZONTAL, 0, EXT_STATE_VERTICAL);
       testStates("aria_vtablist", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
       testStates("aria_toolbar", 0, EXT_STATE_HORIZONTAL, 0, EXT_STATE_VERTICAL);
       testStates("aria_htoolbar", 0, EXT_STATE_HORIZONTAL, 0, EXT_STATE_VERTICAL);
       testStates("aria_vtoolbar", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
       testStates("aria_tree", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
       testStates("aria_htree", 0, EXT_STATE_HORIZONTAL, 0, EXT_STATE_VERTICAL);
       testStates("aria_vtree", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
-      testStates("aria_treegrid", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
+      testStates("aria_treegrid", 0, 0, 0, EXT_STATE_HORIZONTAL | EXT_STATE_VERTICAL);
       testStates("aria_htreegrid", 0, EXT_STATE_HORIZONTAL, 0, EXT_STATE_VERTICAL);
       testStates("aria_vtreegrid", 0, EXT_STATE_VERTICAL, 0, EXT_STATE_HORIZONTAL);
 
       // indeterminate ARIA progressbars (no aria-valuenow or aria-valuetext attribute)
       // should expose mixed state
       testStates("aria_progressbar", STATE_MIXED);
       testStates("aria_progressbar_valuenow", 0, 0, STATE_MIXED);
       testStates("aria_progressbar_valuetext", 0, 0, STATE_MIXED);

--- a/accessible/tests/mochitest/test_aria_token_attrs.html
+++ b/accessible/tests/mochitest/test_aria_token_attrs.html
@@ -91,37 +91,72 @@ https://bugzilla.mozilla.org/show_bug.cg
 
       // test (option) checkable and checked states
       testStates("option_checked_true", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("option_checked_false", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("option_checked_empty", 0 , 0, STATE_CHECKABLE | STATE_CHECKED);
       testStates("option_checked_undefined", 0, 0, STATE_CHECKABLE | STATE_CHECKED);
       testStates("option_checked_absent", 0, 0, STATE_CHECKABLE | STATE_CHECKED);
 
-      // test (menuitem) checkable and checked states
-      testStates("menuitem_checked_true", (STATE_CHECKABLE | STATE_CHECKED));
-      testStates("menuitem_checked_false", STATE_CHECKABLE, 0, STATE_CHECKED);
+      // test (menuitem) checkable and checked states, which are unsupported on this role
+      testStates("menuitem_checked_true", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
+      testStates("menuitem_checked_false", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
       testStates("menuitem_checked_empty", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
       testStates("menuitem_checked_undefined", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
       testStates("menuitem_checked_absent", 0, 0, (STATE_CHECKABLE | STATE_CHECKED));
 
+      // test (menuitemcheckbox) checkable and checked states
+      testStates("menuitemcheckbox_checked_true", (STATE_CHECKABLE | STATE_CHECKED));
+      testStates("menuitemcheckbox_checked_false", STATE_CHECKABLE, 0, STATE_CHECKED);
+      testStates("menuitemcheckbox_checked_empty", STATE_CHECKABLE, 0, STATE_CHECKED);
+      testStates("menuitemcheckbox_checked_undefined", STATE_CHECKABLE, 0, STATE_CHECKED);
+      testStates("menuitemcheckbox_checked_absent", STATE_CHECKABLE, 0, STATE_CHECKED);
+
+      // test (menuitemcheckbox) readonly states
+      testStates("menuitemcheckbox_readonly_true", STATE_READONLY);
+      testStates("menuitemcheckbox_readonly_false", 0, 0, STATE_READONLY);
+      testStates("menuitemcheckbox_readonly_empty", 0, 0, STATE_READONLY);
+      testStates("menuitemcheckbox_readonly_undefined", 0, 0, STATE_READONLY);
+      testStates("menuitemcheckbox_readonly_absent", 0, 0, STATE_READONLY);
+
       // test (menuitemradio) checkable and checked states
       testStates("menuitemradio_checked_true", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("menuitemradio_checked_false", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("menuitemradio_checked_empty", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("menuitemradio_checked_undefined", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("menuitemradio_checked_absent", STATE_CHECKABLE, 0, STATE_CHECKED);
 
+      // test (menuitemradio) readonly states
+      testStates("menuitemradio_readonly_true", STATE_READONLY);
+      testStates("menuitemradio_readonly_false", 0, 0, STATE_READONLY);
+      testStates("menuitemradio_readonly_empty", 0, 0, STATE_READONLY);
+      testStates("menuitemradio_readonly_undefined", 0, 0, STATE_READONLY);
+      testStates("menuitemradio_readonly_absent", 0, 0, STATE_READONLY);
+
       // test (radio) checkable and checked states
       testStates("radio_checked_true", (STATE_CHECKABLE | STATE_CHECKED));
       testStates("radio_checked_false", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("radio_checked_empty", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("radio_checked_undefined", STATE_CHECKABLE, 0, STATE_CHECKED);
       testStates("radio_checked_absent", STATE_CHECKABLE, 0, STATE_CHECKED);
 
+      // test (radiogroup) readonly states
+      testStates("radiogroup_readonly_true", STATE_READONLY);
+      testStates("radiogroup_readonly_false", 0, 0, STATE_READONLY);
+      testStates("radiogroup_readonly_empty", 0, 0, STATE_READONLY);
+      testStates("radiogroup_readonly_undefined", 0, 0, STATE_READONLY);
+      testStates("radiogroup_readonly_absent", 0, 0, STATE_READONLY);
+
+      // test (switch) readonly states
+      testStates("switch_readonly_true", STATE_READONLY);
+      testStates("switch_readonly_false", 0, 0, STATE_READONLY);
+      testStates("switch_readonly_empty", 0, 0, STATE_READONLY);
+      testStates("switch_readonly_undefined", 0, 0, STATE_READONLY);
+      testStates("switch_readonly_absent", 0, 0, STATE_READONLY);
+
       // test (textbox) multiline states
       testStates("textbox_multiline_true", 0, EXT_STATE_MULTI_LINE);
       testStates("textbox_multiline_false", 0, EXT_STATE_SINGLE_LINE);
       testStates("textbox_multiline_empty", 0, EXT_STATE_SINGLE_LINE);
       testStates("textbox_multiline_undefined", 0, EXT_STATE_SINGLE_LINE);
       testStates("textbox_multiline_absent", 0, EXT_STATE_SINGLE_LINE);
 
       // test (textbox) readonly states
@@ -255,35 +290,80 @@ https://bugzilla.mozilla.org/show_bug.cg
   <div id="listbox_multiselectable_undefined" role="listbox" aria-multiselectable="undefined">
     <div id="option_checked_undefined" role="option" aria-checked="undefined">item</div>
   </div>
   <div id="listbox_multiselectable_absent" role="listbox">
     <div id="option_checked_absent" role="option">item</div>
   </div>
 
   <div role="menu">
-    <div id="menuitem_checked_true" role="menuitem" aria-checked="true">This menuitem has aria-checked="true" and should get STATE_CHECKABLE. It should also get STATE_checked.</div>
-    <div id="menuitem_checked_false" role="menuitem" aria-checked="false">This menuitem has aria-checked="false" and should get STATE_CHECKABLE.</div>
-    <div id="menuitem_checked_empty" role="menuitem" aria-checked="">This menuitem has aria-checked="" and should <emph>not</emph> get STATE_CHECKABLE.</div>
-    <div id="menuitem_checked_undefined" role="menuitem" aria-checked="undefined">This menuitem has aria-checked="undefined" and should <emph>not</emph> get STATE_CHECKABLE.</div>
-    <div id="menuitem_checked_absent" role="menuitem">This menuitem has <emph>no</emph> aria-checked attribute and should <emph>not</emph> get STATE_CHECKABLE.</div>
+    <div id="menuitem_checked_true" role="menuitem" aria-checked="true">Generic menuitems don't support aria-checked.</div>
+    <div id="menuitem_checked_false" role="menuitem" aria-checked="false">Generic menuitems don't support aria-checked.</div>
+    <div id="menuitem_checked_empty" role="menuitem" aria-checked="">Generic menuitems don't support aria-checked.</div>
+    <div id="menuitem_checked_undefined" role="menuitem" aria-checked="undefined">Generic menuitems don't support aria-checked.</div>
+    <div id="menuitem_checked_absent" role="menuitem">Generic menuitems don't support aria-checked.</div>
+
+    <div id="menuitemcheckbox_checked_true" role="menuitemcheckbox" aria-checked="true">This menuitemcheckbox has aria-checked="true" and should get STATE_CHECKABLE. It should also get STATE_checked.</div>
+    <div id="menuitemcheckbox_checked_false" role="menuitemcheckbox" aria-checked="false">This menuitemcheckbox has aria-checked="false" and should get STATE_CHECKABLE.</div>
+    <div id="menuitemcheckbox_checked_empty" role="menuitemcheckbox" aria-checked="">This menuitemcheckbox has aria-checked="" and should <emph>not</emph> get STATE_CHECKABLE.</div>
+    <div id="menuitemcheckbox_checked_undefined" role="menuitemcheckbox" aria-checked="undefined">This menuitemcheckbox has aria-checked="undefined" and should <emph>not</emph> get STATE_CHECKABLE.</div>
+    <div id="menuitemcheckbox_checked_absent" role="menuitemcheckbox">This menuitemcheckbox has <emph>no</emph> aria-checked attribute and should <emph>not</emph> get STATE_CHECKABLE.</div>
+
+    <div id="menuitemcheckbox_readonly_true" role="menuitemcheckbox" aria-readonly="true">This menuitemcheckbox has aria-readonly="true" and should get STATE_READONLY.</div>
+    <div id="menuitemcheckbox_readonly_false" role="menuitemcheckbox" aria-readonly="false">This menuitemcheckbox has aria-readonly="false" and should <emph>not</emph> get STATE_READONLY.</div>
+    <div id="menuitemcheckbox_readonly_empty" role="menuitemcheckbox" aria-readonly="">This menuitemcheckbox has aria-readonly="" and should <emph>not</emph> get STATE_READONLY.</div>
+    <div id="menuitemcheckbox_readonly_undefined" role="menuitemcheckbox" aria-readonly="undefined">This menuitemcheckbox has aria-readonly="undefined" and should <emph>not</emph> get STATE_READONLY.</div>
+    <div id="menuitemcheckbox_readonly_absent" role="menuitemcheckbox">This menuitemcheckbox has <emph>no</emph> aria-readonly attribute and should <emph>not</emph> get STATE_READONLY.</div>
 
     <div id="menuitemradio_checked_true" role="menuitemradio" aria-checked="true">This menuitem has aria-checked="true" and should get STATE_CHECKABLE. It should also get STATE_checked.</div>
     <div id="menuitemradio_checked_false" role="menuitemradio" aria-checked="false">This menuitem has aria-checked="false" and should get STATE_CHECKABLE.</div>
     <div id="menuitemradio_checked_empty" role="menuitemradio" aria-checked="">This menuitem has aria-checked="" and should <emph>not</emph> get STATE_CHECKABLE.</div>
     <div id="menuitemradio_checked_undefined" role="menuitemradio" aria-checked="undefined">This menuitem has aria-checked="undefined" and should <emph>not</emph> get STATE_CHECKABLE.</div>
     <div id="menuitemradio_checked_absent" role="menuitemradio">This menuitem has <emph>no</emph> aria-checked attribute but should get STATE_CHECKABLE.</div>
   </div>
 
+    <div id="menuitemradio_readonly_true" role="menuitemradio" aria-readonly="true">This menuitemradio has aria-readonly="true" and should get STATE_READONLY.</div>
+    <div id="menuitemradio_readonly_false" role="menuitemradio" aria-readonly="false">This menuitemradio has aria-readonly="false" and should <emph>not</emph> get STATE_READONLY.</div>
+    <div id="menuitemradio_readonly_empty" role="menuitemradio" aria-readonly="">This menuitemradio has aria-readonly="" and should <emph>not</emph> get STATE_READONLY.</div>
+    <div id="menuitemradio_readonly_undefined" role="menuitemradio" aria-readonly="undefined">This menuitemradio has aria-readonly="undefined" and should <emph>not</emph> get STATE_READONLY.</div>
+    <div id="menuitemradio_readonly_absent" role="menuitemradio">This menuitemradio has <emph>no</emph> aria-readonly attribute and should <emph>not</emph> get STATE_READONLY.</div>
+
   <div id="radio_checked_true" role="radio" aria-checked="true">This menuitem has aria-checked="true" and should get STATE_CHECKABLE. It should also get STATE_CHECKED.</div>
   <div id="radio_checked_false" role="radio" aria-checked="false">This menuitem has aria-checked="false" and should get STATE_CHECKABLE.</div>
   <div id="radio_checked_empty" role="radio" aria-checked="">This menuitem has aria-checked="" and should <emph>not</emph> get STATE_CHECKABLE.</div>
   <div id="radio_checked_undefined" role="radio" aria-checked="undefined">This menuitem has aria-checked="undefined" and should <emph>not</emph> get STATE_CHECKABLE.</div>
   <div id="radio_checked_absent" role="radio">This menuitem has <emph>no</emph> aria-checked attribute but should get STATE_CHECKABLE.</div>
 
+  <div id="radiogroup_readonly_true" role="radiogroup" aria-readonly="true">
+    <div role="radio">yes</div>
+    <div role="radio">no</div>
+  </div>
+  <div id="radiogroup_readonly_false" role="radiogroup" aria-readonly="false">
+    <div role="radio">yes</div>
+    <div role="radio">no</div>
+  </div>
+  <div id="radiogroup_readonly_empty" role="radiogroup" aria-readonly="">
+    <div role="radio">yes</div>
+    <div role="radio">no</div>
+  </div>
+  <div id="radiogroup_readonly_undefined" role="radiogroup" aria-readonly="undefined">
+    <div role="radio">yes</div>
+    <div role="radio">no</div>
+  </div>
+  <div id="radiogroup_readonly_absent" role="radiogroup">
+    <div role="radio">yes</div>
+    <div role="radio">no</div>
+  </div>
+
+  <div id="switch_readonly_true" role="switch" aria-readonly="true">This switch has aria-readonly="true" and should get STATE_READONLY.</div>
+  <div id="switch_readonly_false" role="switch" aria-readonly="false">This switch has aria-readonly="false" and should <emph>not</emph> get STATE_READONLY.</div>
+  <div id="switch_readonly_empty" role="switch" aria-readonly="">This switch has aria-readonly="" and should <emph>not</emph> get STATE_READONLY.</div>
+  <div id="switch_readonly_undefined" role="switch" aria-readonly="undefined">This switch has aria-readonly="undefined" and should <emph>not</emph> get STATE_READONLY.</div>
+  <div id="switch_readonly_absent" role="switch">This switch has <emph>no</emph> aria-readonly attribute and should <emph>not</emph> get STATE_READONLY.</div>
+
   <div id="textbox_readonly_true" role="textbox" aria-readonly="true"></div>
   <div id="textbox_readonly_false" role="textbox" aria-readonly="false"></div>
   <div id="textbox_readonly_empty" role="textbox" aria-readonly=""></div>
   <div id="textbox_readonly_undefined" role="textbox" aria-readonly="undefined"></div>
   <div id="textbox_readonly_absent" role="textbox"></div>
 
   <div id="textbox_multiline_true" role="textbox" aria-multiline="true"></div>
   <div id="textbox_multiline_false" role="textbox" aria-multiline="false"></div>

new file mode 100644
--- /dev/null
+++ b/accessible/windows/msaa/LazyInstantiator.cpp
@@ -0,0 +1,832 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "LazyInstantiator.h"
+
+#include "MainThreadUtils.h"
+#include "mozilla/a11y/Accessible.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/mscom/MainThreadRuntime.h"
+#include "mozilla/mscom/Ptr.h"
+#include "mozilla/mscom/Registration.h"
+#include "mozilla/UniquePtr.h"
+#include "nsAccessibilityService.h"
+#include "nsWindowsHelpers.h"
+#include "nsCOMPtr.h"
+#include "nsIFile.h"
+#include "nsXPCOM.h"
+#include "RootAccessibleWrap.h"
+#include "WinUtils.h"
+
+#if defined(MOZ_TELEMETRY_REPORTING)
+#include "mozilla/Telemetry.h"
+#endif // defined(MOZ_TELEMETRY_REPORTING)
+
+#include <oaidl.h>
+
+#if !defined(STATE_SYSTEM_NORMAL)
+#define STATE_SYSTEM_NORMAL (0)
+#endif // !defined(STATE_SYSTEM_NORMAL)
+
+/**
+ * Because our wrapped accessible is cycle-collected, we can't safely AddRef()
+ * or Release() ourselves off the main thread. This template specialization
+ * forces NewRunnableMethod() to use STAUniquePtr instead of RefPtr for managing
+ * a runnable's lifetime. Once the runnable has completed, the STAUniquePtr will
+ * post a runnable to the main thread to release ourselves from there.
+ */
+template<>
+struct nsRunnableMethodReceiver<mozilla::a11y::LazyInstantiator, true>
+{
+  mozilla::mscom::STAUniquePtr<mozilla::a11y::LazyInstantiator> mObj;
+  explicit nsRunnableMethodReceiver(mozilla::a11y::LazyInstantiator* aObj)
+    : mObj(aObj)
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    // STAUniquePtr does not implicitly AddRef(), so we must explicitly do so
+    // here.
+    aObj->AddRef();
+  }
+  ~nsRunnableMethodReceiver() { Revoke(); }
+  mozilla::a11y::LazyInstantiator* Get() const { return mObj.get(); }
+  void Revoke() { mObj = nullptr; }
+};
+
+namespace mozilla {
+namespace a11y {
+
+static const wchar_t kLazyInstantiatorProp[] = L"mozilla::a11y::LazyInstantiator";
+
+/* static */
+already_AddRefed<IAccessible>
+LazyInstantiator::GetRootAccessible(HWND aHwnd)
+{
+  // There must only be one LazyInstantiator per HWND.
+  // To track this, we set the kLazyInstantiatorProp on the HWND with a pointer
+  // to an existing instance. We only create a new LazyInstatiator if that prop
+  // has not already been set.
+  LazyInstantiator* existingInstantiator =
+    reinterpret_cast<LazyInstantiator*>(::GetProp(aHwnd, kLazyInstantiatorProp));
+
+  RefPtr<IAccessible> result;
+  if (existingInstantiator) {
+    // Temporarily disable blind aggregation until we know that we have been
+    // marshaled. See EnableBlindAggregation for more information.
+    existingInstantiator->mAllowBlindAggregation = false;
+    result = existingInstantiator;
+    return result.forget();
+  }
+
+  // At this time we only want to check whether the acc service is running; We
+  // don't actually want to create the acc service yet.
+  if (!GetAccService()) {
+    // a11y is not running yet, there are no existing LazyInstantiators for this
+    // HWND, so create a new one and return it as a surrogate for the root
+    // accessible.
+    result = new LazyInstantiator(aHwnd);
+    return result.forget();
+  }
+
+  // a11y is running, so we just resolve the real root accessible.
+  a11y::Accessible* rootAcc = widget::WinUtils::GetRootAccessibleForHWND(aHwnd);
+  if (!rootAcc || !rootAcc->IsRoot()) {
+    return nullptr;
+  }
+
+  // Subtle: rootAcc might still be wrapped by a LazyInstantiator, but we
+  // don't need LazyInstantiator's capabilities anymore (since a11y is already
+  // running). We can bypass LazyInstantiator by retrieving the internal
+  // unknown (which is not wrapped by the LazyInstantiator) and then querying
+  // that for IID_IAccessible.
+  a11y::RootAccessibleWrap* rootWrap =
+    static_cast<a11y::RootAccessibleWrap*>(rootAcc);
+  RefPtr<IUnknown> punk(rootWrap->GetInternalUnknown());
+
+  MOZ_ASSERT(punk);
+  if (!punk) {
+    return nullptr;
+  }
+
+  punk->QueryInterface(IID_IAccessible, getter_AddRefs(result));
+  return result.forget();
+}
+
+/**
+ * When marshaling an interface, COM makes a whole bunch of QueryInterface
+ * calls to determine what kind of marshaling the interface supports. We need
+ * to handle those queries without instantiating a11y, so we temporarily
+ * disable passing through of QueryInterface calls to a11y. Once we know that
+ * COM is finished marshaling, we call EnableBlindAggregation to re-enable
+ * QueryInterface passthrough.
+ */
+/* static */
+void
+LazyInstantiator::EnableBlindAggregation(HWND aHwnd)
+{
+  LazyInstantiator* existingInstantiator =
+    reinterpret_cast<LazyInstantiator*>(::GetProp(aHwnd, kLazyInstantiatorProp));
+
+  if (!existingInstantiator) {
+    return;
+  }
+
+  existingInstantiator->mAllowBlindAggregation = true;
+}
+
+LazyInstantiator::LazyInstantiator(HWND aHwnd)
+  : mHwnd(aHwnd)
+  , mAllowBlindAggregation(false)
+  , mWeakRootAccWrap(nullptr)
+  , mWeakAccessible(nullptr)
+  , mWeakDispatch(nullptr)
+{
+  MOZ_ASSERT(aHwnd);
+  // Assign ourselves as the designated LazyInstantiator for aHwnd
+  DebugOnly<BOOL> setPropOk = ::SetProp(aHwnd, kLazyInstantiatorProp,
+                                        reinterpret_cast<HANDLE>(this));
+  MOZ_ASSERT(setPropOk);
+}
+
+LazyInstantiator::~LazyInstantiator()
+{
+  if (mRealRootUnk) {
+    // Disconnect ourselves from the root accessible.
+    RefPtr<IUnknown> dummy(mWeakRootAccWrap->Aggregate(nullptr));
+  }
+
+  ClearProp();
+}
+
+void
+LazyInstantiator::ClearProp()
+{
+  // Remove ourselves as the designated LazyInstantiator for mHwnd
+  DebugOnly<HANDLE> removedProp = ::RemoveProp(mHwnd, kLazyInstantiatorProp);
+  MOZ_ASSERT(!removedProp ||
+             reinterpret_cast<LazyInstantiator*>(removedProp.value) == this);
+}
+
+/**
+ * Given the remote client's thread ID, resolve its execuatable image name.
+ */
+bool
+LazyInstantiator::GetClientExecutableName(const DWORD aClientTid,
+                                          nsIFile** aOutClientExe)
+{
+  nsAutoHandle callingThread(::OpenThread(THREAD_QUERY_LIMITED_INFORMATION,
+                                          FALSE, aClientTid));
+  if (!callingThread) {
+    return false;
+  }
+
+  DWORD callingPid = ::GetProcessIdOfThread(callingThread);
+
+  nsAutoHandle callingProcess(::OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION,
+                                            FALSE, callingPid));
+  if (!callingProcess) {
+    return false;
+  }
+
+  DWORD bufLen = MAX_PATH;
+  UniquePtr<wchar_t[]> buf;
+
+  while (true) {
+    buf = MakeUnique<wchar_t[]>(bufLen);
+    if (::QueryFullProcessImageName(callingProcess, 0, buf.get(), &bufLen)) {
+      break;
+    }
+
+    DWORD lastError = ::GetLastError();
+    MOZ_ASSERT(lastError == ERROR_INSUFFICIENT_BUFFER);
+    if (lastError != ERROR_INSUFFICIENT_BUFFER) {
+      return false;
+    }
+
+    bufLen *= 2;
+  }
+
+  nsCOMPtr<nsIFile> file;
+  nsresult rv = NS_NewLocalFile(nsDependentString(buf.get(), bufLen), false,
+                                getter_AddRefs(file));
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  file.forget(aOutClientExe);
+  return NS_SUCCEEDED(rv);
+}
+
+/**
+ * Given a remote client's thread ID, determine whether we should proceed with
+ * a11y instantiation. This is where telemetry should be gathered and any
+ * potential blocking of unwanted a11y clients should occur.
+ *
+ * @return true if we should instantiate a11y
+ */
+bool
+LazyInstantiator::ShouldInstantiate(const DWORD aClientTid)
+{
+  if (!aClientTid) {
+    // aClientTid == 0 implies that this is either an in-process call, or else
+    // we failed to retrieve information about the remote caller.
+    // We should always default to instantiating a11y in this case.
+    return true;
+  }
+
+  nsCOMPtr<nsIFile> clientExe;
+  GetClientExecutableName(aClientTid, getter_AddRefs(clientExe));
+
+  // Blocklist checks should go here. return false if we should not instantiate.
+  /*
+  if (ClientShouldBeBlocked(clientExe)) {
+    return false;
+  }
+  */
+
+#if defined(MOZ_TELEMETRY_REPORTING)
+  if (!mTelemetryThread) {
+    // Call GatherTelemetry on a background thread because it does I/O on
+    // the executable file to retrieve version information.
+    nsCOMPtr<nsIRunnable> runnable(
+        NewRunnableMethod<nsCOMPtr<nsIFile>>(this,
+                                             &LazyInstantiator::GatherTelemetry,
+                                             clientExe));
+    NS_NewThread(getter_AddRefs(mTelemetryThread), runnable);
+  }
+#endif // defined(MOZ_TELEMETRY_REPORTING)
+  return true;
+}
+
+#if defined(MOZ_TELEMETRY_REPORTING)
+/**
+ * Appends version information in the format "|a.b.c.d".
+ * If there is no version information, we append nothing.
+ */
+void
+LazyInstantiator::AppendVersionInfo(nsIFile* aClientExe,
+                                    nsAString& aStrToAppend)
+{
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  nsAutoString fullPath;
+  nsresult rv = aClientExe->GetPath(fullPath);
+  if (NS_FAILED(rv)) {
+    return;
+  }
+
+  DWORD verInfoSize = ::GetFileVersionInfoSize(fullPath.get(), nullptr);
+  if (!verInfoSize) {
+    return;
+  }
+
+  auto verInfoBuf = MakeUnique<BYTE[]>(verInfoSize);
+
+  if (!::GetFileVersionInfo(fullPath.get(), 0, verInfoSize, verInfoBuf.get())) {
+    return;
+  }
+
+  VS_FIXEDFILEINFO* fixedInfo = nullptr;
+  UINT fixedInfoLen = 0;
+
+  if (!::VerQueryValue(verInfoBuf.get(), L"\\", (LPVOID*) &fixedInfo,
+                       &fixedInfoLen)) {
+    return;
+  }
+
+  uint32_t major = HIWORD(fixedInfo->dwFileVersionMS);
+  uint32_t minor = LOWORD(fixedInfo->dwFileVersionMS);
+  uint32_t patch = HIWORD(fixedInfo->dwFileVersionLS);
+  uint32_t build = LOWORD(fixedInfo->dwFileVersionLS);
+
+  aStrToAppend.AppendLiteral(u"|");
+
+  NS_NAMED_LITERAL_STRING(dot, ".");
+
+  aStrToAppend.AppendInt(major);
+  aStrToAppend.Append(dot);
+  aStrToAppend.AppendInt(minor);
+  aStrToAppend.Append(dot);
+  aStrToAppend.AppendInt(patch);
+  aStrToAppend.Append(dot);
+  aStrToAppend.AppendInt(build);
+}
+
+void
+LazyInstantiator::GatherTelemetry(nsIFile* aClientExe)
+{
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  nsAutoString value;
+  nsresult rv = aClientExe->GetLeafName(value);
+  if (NS_SUCCEEDED(rv)) {
+    AppendVersionInfo(aClientExe, value);
+  }
+
+  // Now that we've (possibly) obtained version info, send the resulting
+  // string back to the main thread to accumulate in telemetry.
+  NS_DispatchToMainThread(NewNonOwningRunnableMethod<nsString>(this,
+        &LazyInstantiator::AccumulateTelemetry, value));
+}
+
+void
+LazyInstantiator::AccumulateTelemetry(const nsString& aValue)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!aValue.IsEmpty()) {
+    Telemetry::ScalarSet(Telemetry::ScalarID::A11Y_INSTANTIATORS, aValue);
+  }
+
+  mTelemetryThread->Shutdown();
+  mTelemetryThread = nullptr;
+}
+#endif // defined(MOZ_TELEMETRY_REPORTING)
+
+RootAccessibleWrap*
+LazyInstantiator::ResolveRootAccWrap()
+{
+  Accessible* acc = widget::WinUtils::GetRootAccessibleForHWND(mHwnd);
+  if (!acc || !acc->IsRoot()) {
+    return nullptr;
+  }
+
+  return static_cast<RootAccessibleWrap*>(acc);
+}
+
+/**
+ * With COM aggregation, the aggregated inner object usually delegates its
+ * reference counting to the outer object. In other words, we would expect
+ * mRealRootUnk to delegate its AddRef() and Release() to this LazyInstantiator.
+ *
+ * This scheme will not work in our case because the RootAccessibleWrap is
+ * cycle-collected!
+ *
+ * Instead, once a LazyInstantiator aggregates a RootAccessibleWrap, we transfer
+ * our strong references into mRealRootUnk. Any future calls to AddRef or
+ * Release now operate on mRealRootUnk instead of our intrinsic reference
+ * count. This is a bit strange, but it is the only way for these objects to
+ * share their reference count in a way that is safe for cycle collection.
+ *
+ * How do we know when it is safe to destroy ourselves? In
+ * LazyInstantiator::Release, we examine the result of mRealRootUnk->Release().
+ * If mRealRootUnk's resulting refcount is 1, then we know that the only
+ * remaining reference to mRealRootUnk is the mRealRootUnk reference itself (and
+ * thus nobody else holds references to either this or mRealRootUnk). Therefore
+ * we may now delete ourselves.
+ */
+void
+LazyInstantiator::TransplantRefCnt()
+{
+  MOZ_ASSERT(mRefCnt > 0);
+  MOZ_ASSERT(mRealRootUnk);
+
+  while (mRefCnt > 0) {
+    mRealRootUnk.get()->AddRef();
+    --mRefCnt;
+  }
+}
+
+HRESULT
+LazyInstantiator::MaybeResolveRoot()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mWeakAccessible) {
+    return S_OK;
+  }
+
+  if (GetAccService() ||
+      ShouldInstantiate(mscom::MainThreadRuntime::GetClientThreadId())) {
+    mWeakRootAccWrap = ResolveRootAccWrap();
+    if (!mWeakRootAccWrap) {
+      return E_POINTER;
+    }
+
+    // Wrap ourselves around the root accessible wrap
+    mRealRootUnk = mWeakRootAccWrap->Aggregate(static_cast<IAccessible*>(this));
+    if (!mRealRootUnk) {
+      return E_FAIL;
+    }
+
+    // Move our strong references into the root accessible (see the comments
+    // above TransplantRefCnt for explanation).
+    TransplantRefCnt();
+
+    // Now obtain mWeakAccessible which we use to forward our incoming calls
+    // to the real accesssible.
+    HRESULT hr = mRealRootUnk->QueryInterface(IID_IAccessible,
+                                              (void**) &mWeakAccessible);
+    if (FAILED(hr)) {
+      return hr;
+    }
+
+    // mWeakAccessible is weak, so don't hold a strong ref
+    mWeakAccessible->Release();
+
+    // Now that a11y is running, we don't need to remain registered with our
+    // HWND anymore.
+    ClearProp();
+
+    return S_OK;
+  }
+
+  // If we don't want a real root, let's resolve a fake one.
+
+  const WPARAM flags = 0xFFFFFFFFUL;
+  // Synthesize a WM_GETOBJECT request to obtain a system-implemented
+  // IAccessible object from DefWindowProc
+  LRESULT lresult = ::DefWindowProc(mHwnd, WM_GETOBJECT, flags,
+                                    static_cast<LPARAM>(OBJID_CLIENT));
+
+  HRESULT hr = ObjectFromLresult(lresult, IID_IAccessible, flags,
+                                 getter_AddRefs(mRealRootUnk));
+  if (FAILED(hr)) {
+    return hr;
+  }
+
+  if (!mRealRootUnk) {
+    return E_NOTIMPL;
+  }
+
+  hr = mRealRootUnk->QueryInterface(IID_IAccessible,
+                                    (void**) &mWeakAccessible);
+  if (FAILED(hr)) {
+    return hr;
+  }
+
+  // mWeakAccessible is weak, so don't hold a strong ref
+  mWeakAccessible->Release();
+
+  return S_OK;
+}
+
+#define RESOLVE_ROOT \
+  { \
+    HRESULT hr = MaybeResolveRoot(); \
+    if (FAILED(hr)) { \
+      return hr; \
+    } \
+  }
+
+IMPL_IUNKNOWN_QUERY_HEAD(LazyInstantiator)
+IMPL_IUNKNOWN_QUERY_IFACE_AMBIGIOUS(IUnknown, IAccessible)
+IMPL_IUNKNOWN_QUERY_IFACE(IAccessible)
+IMPL_IUNKNOWN_QUERY_IFACE(IDispatch)
+IMPL_IUNKNOWN_QUERY_IFACE(IServiceProvider)
+  // See EnableBlindAggregation for comments.
+  if (!mAllowBlindAggregation) {
+    return E_NOINTERFACE;
+  }
+// If the client queries for an interface that LazyInstantiator does not
+// intrinsically support, then we must resolve the root accessible and pass
+// on the QueryInterface call to mRealRootUnk.
+RESOLVE_ROOT
+IMPL_IUNKNOWN_QUERY_TAIL_AGGREGATED(mRealRootUnk)
+
+ULONG
+LazyInstantiator::AddRef()
+{
+  // Always delegate refcounting to mRealRootUnk when it exists
+  if (mRealRootUnk) {
+    return mRealRootUnk.get()->AddRef();
+  }
+
+  return ++mRefCnt;
+}
+
+ULONG
+LazyInstantiator::Release()
+{
+  ULONG result;
+
+  // Always delegate refcounting to mRealRootUnk when it exists
+  if (mRealRootUnk) {
+    result = mRealRootUnk.get()->Release();
+    if (result == 1) {
+      // mRealRootUnk is the only strong reference left, so nothing else holds
+      // a strong reference to us. Drop result to zero so that we destroy
+      // ourselves (See the comments above LazyInstantiator::TransplantRefCnt
+      // for more info).
+      --result;
+    }
+  } else {
+    result = --mRefCnt;
+  }
+
+  if (!result) {
+    delete this;
+  }
+  return result;
+}
+
+/**
+ * Create a standard IDispatch implementation. mStdDispatch will translate any
+ * IDispatch::Invoke calls into real IAccessible calls.
+ */
+HRESULT
+LazyInstantiator::ResolveDispatch()
+{
+  if (mWeakDispatch) {
+    return S_OK;
+  }
+
+  // The IAccessible typelib is embedded in oleacc.dll's resources.
+  auto typelib = mscom::RegisterTypelib(L"oleacc.dll",
+                                        mscom::RegistrationFlags::eUseSystemDirectory);
+  if (!typelib) {
+    return E_UNEXPECTED;
+  }
+
+  // Extract IAccessible's type info
+  RefPtr<ITypeInfo> accTypeInfo;
+  HRESULT hr = typelib->GetTypeInfoForGuid(IID_IAccessible,
+                                           getter_AddRefs(accTypeInfo));
+  if (FAILED(hr)) {
+    return hr;
+  }
+
+  // Now create the standard IDispatch for IAccessible
+  hr = ::CreateStdDispatch(static_cast<IAccessible*>(this),
+                           static_cast<IAccessible*>(this),
+                           accTypeInfo, getter_AddRefs(mStdDispatch));
+  if (FAILED(hr)) {
+    return hr;
+  }
+
+  hr = mStdDispatch->QueryInterface(IID_IDispatch, (void**)&mWeakDispatch);
+  if (FAILED(hr)) {
+    return hr;
+  }
+
+  // WEAK reference
+  mWeakDispatch->Release();
+  return S_OK;
+}
+
+#define RESOLVE_IDISPATCH \
+  { \
+    HRESULT hr = ResolveDispatch(); \
+    if (FAILED(hr)) { \
+      return hr; \
+    } \
+  }
+
+/**
+ * The remaining methods implement IDispatch, IAccessible, and IServiceProvider,
+ * lazily resolving the real a11y objects and passing the call through.
+ */
+
+HRESULT
+LazyInstantiator::GetTypeInfoCount(UINT* pctinfo)
+{
+  RESOLVE_IDISPATCH;
+  return mWeakDispatch->GetTypeInfoCount(pctinfo);
+}
+
+HRESULT
+LazyInstantiator::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
+{
+  RESOLVE_IDISPATCH;
+  return mWeakDispatch->GetTypeInfo(iTInfo, lcid, ppTInfo);
+}
+
+HRESULT
+LazyInstantiator::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
+                                LCID lcid, DISPID* rgDispId)
+{
+  RESOLVE_IDISPATCH;
+  return mWeakDispatch->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
+}
+
+HRESULT
+LazyInstantiator::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
+                         WORD wFlags, DISPPARAMS* pDispParams,
+                         VARIANT* pVarResult, EXCEPINFO* pExcepInfo,
+                         UINT* puArgErr)
+{
+  RESOLVE_IDISPATCH;
+  return mWeakDispatch->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams,
+                               pVarResult, pExcepInfo, puArgErr);
+}
+
+HRESULT
+LazyInstantiator::get_accParent(IDispatch **ppdispParent)
+{
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accParent(ppdispParent);
+}
+
+HRESULT
+LazyInstantiator::get_accChildCount(long *pcountChildren)
+{
+  if (!pcountChildren) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accChildCount(pcountChildren);
+}
+
+HRESULT
+LazyInstantiator::get_accChild(VARIANT varChild, IDispatch **ppdispChild)
+{
+  if (!ppdispChild) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accChild(varChild, ppdispChild);
+}
+
+HRESULT
+LazyInstantiator::get_accName(VARIANT varChild, BSTR *pszName)
+{
+  if (!pszName) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accName(varChild, pszName);
+}
+
+HRESULT
+LazyInstantiator::get_accValue(VARIANT varChild, BSTR *pszValue)
+{
+  if (!pszValue) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accValue(varChild, pszValue);
+}
+
+HRESULT
+LazyInstantiator::get_accDescription(VARIANT varChild, BSTR *pszDescription)
+{
+  if (!pszDescription) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accDescription(varChild, pszDescription);
+}
+
+HRESULT
+LazyInstantiator::get_accRole(VARIANT varChild, VARIANT *pvarRole)
+{
+  if (!pvarRole) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accRole(varChild, pvarRole);
+}
+
+HRESULT
+LazyInstantiator::get_accState(VARIANT varChild, VARIANT *pvarState)
+{
+  if (!pvarState) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accState(varChild, pvarState);
+}
+
+HRESULT
+LazyInstantiator::get_accHelp(VARIANT varChild, BSTR *pszHelp)
+{
+  return E_NOTIMPL;
+}
+
+HRESULT
+LazyInstantiator::get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild,
+                                   long *pidTopic)
+{
+  return E_NOTIMPL;
+}
+
+HRESULT
+LazyInstantiator::get_accKeyboardShortcut(VARIANT varChild,
+                                          BSTR *pszKeyboardShortcut)
+{
+  if (!pszKeyboardShortcut) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accKeyboardShortcut(varChild, pszKeyboardShortcut);
+}
+
+HRESULT
+LazyInstantiator::get_accFocus(VARIANT *pvarChild)
+{
+  if (!pvarChild) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accFocus(pvarChild);
+}
+
+HRESULT
+LazyInstantiator::get_accSelection(VARIANT *pvarChildren)
+{
+  if (!pvarChildren) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accSelection(pvarChildren);
+}
+
+HRESULT
+LazyInstantiator::get_accDefaultAction(VARIANT varChild, BSTR *pszDefaultAction)
+{
+  if (!pszDefaultAction) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->get_accDefaultAction(varChild, pszDefaultAction);
+}
+
+HRESULT
+LazyInstantiator::accSelect(long flagsSelect, VARIANT varChild)
+{
+  RESOLVE_ROOT;
+  return mWeakAccessible->accSelect(flagsSelect, varChild);
+}
+
+HRESULT
+LazyInstantiator::accLocation(long *pxLeft, long *pyTop, long *pcxWidth,
+                              long *pcyHeight, VARIANT varChild)
+{
+  RESOLVE_ROOT;
+  return mWeakAccessible->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varChild);
+}
+
+HRESULT
+LazyInstantiator::accNavigate(long navDir, VARIANT varStart,
+                              VARIANT *pvarEndUpAt)
+{
+  return E_NOTIMPL;
+}
+
+HRESULT
+LazyInstantiator::accHitTest(long xLeft, long yTop, VARIANT *pvarChild)
+{
+  if (!pvarChild) {
+    return E_INVALIDARG;
+  }
+
+  RESOLVE_ROOT;
+  return mWeakAccessible->accHitTest(xLeft, yTop, pvarChild);
+}
+
+HRESULT
+LazyInstantiator::accDoDefaultAction(VARIANT varChild)
+{
+  RESOLVE_ROOT;
+  return mWeakAccessible->accDoDefaultAction(varChild);
+}
+
+HRESULT
+LazyInstantiator::put_accName(VARIANT varChild, BSTR szName)
+{
+  return E_NOTIMPL;
+}
+
+HRESULT
+LazyInstantiator::put_accValue(VARIANT varChild, BSTR szValue)
+{
+  return E_NOTIMPL;
+}
+
+HRESULT
+LazyInstantiator::QueryService(REFGUID aServiceId, REFIID aServiceIid,
+                               void** aOutInterface)
+{
+  if (!aOutInterface) {
+    return E_INVALIDARG;
+  }
+
+  *aOutInterface = nullptr;
+
+  RESOLVE_ROOT;
+
+  RefPtr<IServiceProvider> servProv;
+  HRESULT hr = mRealRootUnk->QueryInterface(IID_IServiceProvider,
+                                            getter_AddRefs(servProv));
+  if (FAILED(hr)) {
+    return hr;
+  }
+
+  return servProv->QueryService(aServiceId, aServiceIid, aOutInterface);
+}
+
+} // namespace a11y
+} // namespace mozilla
+

new file mode 100644
--- /dev/null
+++ b/accessible/windows/msaa/LazyInstantiator.h
@@ -0,0 +1,133 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_a11y_LazyInstantiator_h
+#define mozilla_a11y_LazyInstantiator_h
+
+#include "IUnknownImpl.h"
+#include "mozilla/RefPtr.h"
+#include "nsString.h"
+#if defined(MOZ_TELEMETRY_REPORTING)
+#include "nsThreadUtils.h"
+#endif // defined(MOZ_TELEMETRY_REPORTING)
+
+#include <oleacc.h>
+
+class nsIFile;
+
+namespace mozilla {
+namespace a11y {
+
+class RootAccessibleWrap;
+
+/**
+ * LazyInstantiator is an IAccessible that initially acts as a placeholder.
+ * The a11y service is not actually started until two conditions are met:
+ *
+ * (1) A method is called on the LazyInstantiator that would require a11y
+ *     services in order to fulfill; and
+ * (2) LazyInstantiator::ShouldInstantiate returns true.
+ */
+class LazyInstantiator final : public IAccessible
+                             , public IServiceProvider
+{
+public:
+  static already_AddRefed<IAccessible> GetRootAccessible(HWND aHwnd);
+  static void EnableBlindAggregation(HWND aHwnd);
+
+  // IUnknown
+  STDMETHODIMP QueryInterface(REFIID aIid, void** aOutInterface) override;
+  STDMETHODIMP_(ULONG) AddRef() override;
+  STDMETHODIMP_(ULONG) Release() override;
+
+  // IDispatch
+  STDMETHODIMP GetTypeInfoCount(UINT* pctinfo) override;
+  STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) override;
+  STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
+                             LCID lcid, DISPID* rgDispId) override;
+  STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
+                      DISPPARAMS* pDispParams, VARIANT* pVarResult,
+                      EXCEPINFO* pExcepInfo, UINT* puArgErr) override;
+
+  // IAccessible
+  STDMETHODIMP get_accParent(IDispatch **ppdispParent) override;
+  STDMETHODIMP get_accChildCount(long *pcountChildren) override;
+  STDMETHODIMP get_accChild(VARIANT varChild, IDispatch **ppdispChild) override;
+  STDMETHODIMP get_accName(VARIANT varChild, BSTR *pszName) override;
+  STDMETHODIMP get_accValue(VARIANT varChild, BSTR *pszValue) override;
+  STDMETHODIMP get_accDescription(VARIANT varChild, BSTR *pszDescription) override;
+  STDMETHODIMP get_accRole(VARIANT varChild, VARIANT *pvarRole) override;
+  STDMETHODIMP get_accState(VARIANT varChild, VARIANT *pvarState) override;
+  STDMETHODIMP get_accHelp(VARIANT varChild, BSTR *pszHelp) override;
+  STDMETHODIMP get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild, long *pidTopic) override;
+  STDMETHODIMP get_accKeyboardShortcut(VARIANT varChild, BSTR *pszKeyboardShortcut) override;
+  STDMETHODIMP get_accFocus(VARIANT *pvarChild) override;
+  STDMETHODIMP get_accSelection(VARIANT *pvarChildren) override;
+  STDMETHODIMP get_accDefaultAction(VARIANT varChild, BSTR *pszDefaultAction) override;
+  STDMETHODIMP accSelect(long flagsSelect, VARIANT varChild) override;
+  STDMETHODIMP accLocation(long *pxLeft, long *pyTop, long *pcxWidth, long *pcyHeight, VARIANT varChild) override;
+  STDMETHODIMP accNavigate(long navDir, VARIANT varStart, VARIANT *pvarEndUpAt) override;
+  STDMETHODIMP accHitTest(long xLeft, long yTop, VARIANT *pvarChild) override;
+  STDMETHODIMP accDoDefaultAction(VARIANT varChild) override;
+  STDMETHODIMP put_accName(VARIANT varChild, BSTR szName) override;
+  STDMETHODIMP put_accValue(VARIANT varChild, BSTR szValue) override;
+
+  // IServiceProvider
+  STDMETHODIMP QueryService(REFGUID aServiceId, REFIID aServiceIid, void** aOutInterface) override;
+
+private:
+  explicit LazyInstantiator(HWND aHwnd);
+  ~LazyInstantiator();
+
+  bool ShouldInstantiate(const DWORD aClientTid);
+
+  bool GetClientExecutableName(const DWORD aClientTid, nsIFile** aOutClientExe);
+#if defined(MOZ_TELEMETRY_REPORTING)
+  void AppendVersionInfo(nsIFile* aClientExe, nsAString& aStrToAppend);
+  void GatherTelemetry(nsIFile* aClientExe);
+  void AccumulateTelemetry(const nsString& aValue);
+#endif // defined(MOZ_TELEMETRY_REPORTING)
+
+  /**
+   * @return S_OK if we have a valid mRealRoot to invoke methods on
+   */
+  HRESULT MaybeResolveRoot();
+
+  /**
+   * @return S_OK if we have a valid mWeakDispatch to invoke methods on
+   */
+  HRESULT ResolveDispatch();
+
+  RootAccessibleWrap* ResolveRootAccWrap();
+  void TransplantRefCnt();
+  void ClearProp();
+
+private:
+  mozilla::a11y::AutoRefCnt mRefCnt;
+  HWND                mHwnd;
+  bool                mAllowBlindAggregation;
+  RefPtr<IUnknown>    mRealRootUnk;
+  RefPtr<IUnknown>    mStdDispatch;
+  /**
+   * mWeakRootAccWrap, mWeakAccessible and mWeakDispatch are weak because they
+   * are interfaces that come from objects that we aggregate. Aggregated object
+   * interfaces share refcount methods with ours, so if we were to hold strong
+   * references to them, we would be holding strong references to ourselves,
+   * creating a cycle.
+   */
+  RootAccessibleWrap* mWeakRootAccWrap;
+  IAccessible*        mWeakAccessible;
+  IDispatch*          mWeakDispatch;
+#if defined(MOZ_TELEMETRY_REPORTING)
+  nsCOMPtr<nsIThread> mTelemetryThread;
+#endif // defined(MOZ_TELEMETRY_REPORTING)
+};
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif // mozilla_a11y_LazyInstantiator_h
+

--- a/accessible/windows/msaa/RootAccessibleWrap.cpp
+++ b/accessible/windows/msaa/RootAccessibleWrap.cpp
@@ -9,27 +9,84 @@
 #include "nsCoreUtils.h"
 #include "nsWinUtils.h"
 
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Constructor/destructor
 
-RootAccessibleWrap::
-  RootAccessibleWrap(nsIDocument* aDocument, nsIPresShell* aPresShell) :
-  RootAccessible(aDocument, aPresShell)
+RootAccessibleWrap::RootAccessibleWrap(nsIDocument* aDocument,
+                                       nsIPresShell* aPresShell)
+  : RootAccessible(aDocument, aPresShell)
+  , mOuter(&mInternalUnknown)
 {
 }
 
 RootAccessibleWrap::~RootAccessibleWrap()
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Aggregated IUnknown
+HRESULT
+RootAccessibleWrap::InternalQueryInterface(REFIID aIid, void** aOutInterface)
+{
+  if (!aOutInterface) {
+    return E_INVALIDARG;
+  }
+
+  // InternalQueryInterface should always return its internal unknown
+  // when queried for IID_IUnknown...
+  if (aIid == IID_IUnknown) {
+    RefPtr<IUnknown> punk(&mInternalUnknown);
+    punk.forget(aOutInterface);
+    return S_OK;
+  }
+
+  // ...Otherwise we pass through to the base COM implementation of
+  // QueryInterface which is provided by DocAccessibleWrap.
+  return DocAccessibleWrap::QueryInterface(aIid, aOutInterface);
+}
+
+ULONG
+RootAccessibleWrap::InternalAddRef()
+{
+  return DocAccessible::AddRef();
+}
+
+ULONG
+RootAccessibleWrap::InternalRelease()
+{
+  return DocAccessible::Release();
+}
+
+already_AddRefed<IUnknown>
+RootAccessibleWrap::Aggregate(IUnknown* aOuter)
+{
+  MOZ_ASSERT(mOuter && (mOuter == &mInternalUnknown || mOuter == aOuter || !aOuter));
+  if (!aOuter) {
+    // If there is no aOuter then we should always set mOuter to
+    // mInternalUnknown. This is standard COM aggregation stuff.
+    mOuter = &mInternalUnknown;
+    return nullptr;
+  }
+
+  mOuter = aOuter;
+  return GetInternalUnknown();
+}
+
+already_AddRefed<IUnknown>
+RootAccessibleWrap::GetInternalUnknown()
+{
+  RefPtr<IUnknown> result(&mInternalUnknown);
+  return result.forget();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // RootAccessible
 
 void
 RootAccessibleWrap::DocumentActivated(DocAccessible* aDocument)
 {
   if (Compatibility::IsDolphin() &&
       nsCoreUtils::IsTabDocument(aDocument->DocumentNode())) {
     uint32_t count = mChildDocuments.Length();

--- a/accessible/windows/msaa/RootAccessibleWrap.h
+++ b/accessible/windows/msaa/RootAccessibleWrap.h
@@ -1,27 +1,51 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/. */
 
 #ifndef mozilla_a11y_RootAccessibleWrap_h__
 #define mozilla_a11y_RootAccessibleWrap_h__
 
+#include "mozilla/mscom/Aggregation.h"
 #include "RootAccessible.h"
 
 namespace mozilla {
 namespace a11y {
 
 class RootAccessibleWrap : public RootAccessible
 {
 public:
   RootAccessibleWrap(nsIDocument* aDocument, nsIPresShell* aPresShell);
   virtual ~RootAccessibleWrap();
 
   // RootAccessible
   virtual void DocumentActivated(DocAccessible* aDocument);
+
+  /**
+   * This method enables a RootAccessibleWrap to be wrapped by a
+   * LazyInstantiator.
+   *
+   * @param aOuter The IUnknown of the object that is wrapping this
+   *               RootAccessibleWrap, or nullptr to unwrap the aOuter from
+   *               a previous call.
+   * @return This objects own IUnknown (as opposed to aOuter's IUnknown).
+   */
+  already_AddRefed<IUnknown> Aggregate(IUnknown* aOuter);
+
+  /**
+   * @return This object's own IUnknown, as opposed to its wrapper's IUnknown
+   *         which is what would be returned by QueryInterface(IID_IUnknown).
+   */
+  already_AddRefed<IUnknown> GetInternalUnknown();
+
+private:
+  // DECLARE_AGGREGATABLE declares the internal IUnknown methods as well as
+  // mInternalUnknown.
+  DECLARE_AGGREGATABLE(RootAccessibleWrap);
+  IUnknown* mOuter;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif

--- a/accessible/windows/msaa/moz.build
+++ b/accessible/windows/msaa/moz.build
@@ -8,16 +8,17 @@ EXPORTS += [
     'IUnknownImpl.h',
 ]
 
 EXPORTS.mozilla.a11y += [
     'AccessibleWrap.h',
     'Compatibility.h',
     'HyperTextAccessibleWrap.h',
     'IDSet.h',
+    'LazyInstantiator.h',
     'MsaaIdGenerator.h',
     'nsWinUtils.h',
 ]
 
 UNIFIED_SOURCES += [
     'AccessibleWrap.cpp',
     'ApplicationAccessibleWrap.cpp',
     'ARIAGridAccessibleWrap.cpp',
@@ -32,18 +33,20 @@ UNIFIED_SOURCES += [
     'IUnknownImpl.cpp',
     'MsaaIdGenerator.cpp',
     'nsWinUtils.cpp',
     'Platform.cpp',
     'RootAccessibleWrap.cpp',
     'TextLeafAccessibleWrap.cpp',
 ]
 
-# This file cannot be built in unified mode because it includes ISimpleDOMNode_i.c.
 SOURCES += [
+    # This file cannot be built in unified mode because it redefines _WIN32_WINNT
+    'LazyInstantiator.cpp',
+    # This file cannot be built in unified mode because it includes ISimpleDOMNode_i.c.
     'ServiceProvider.cpp',
 ]
 
 if CONFIG['MOZ_XUL']:
     UNIFIED_SOURCES += [
         'XULListboxAccessibleWrap.cpp',
         'XULMenuAccessibleWrap.cpp',
         'XULTreeGridAccessibleWrap.cpp',

--- a/addon-sdk/source/lib/sdk/addon/runner.js
+++ b/addon-sdk/source/lib/sdk/addon/runner.js
@@ -65,28 +65,28 @@ function startup(reason, options) {
 
     // NOTE: Module is intentionally required only now because it relies
     // on existence of hidden window, which does not exists until startup.
     let { ready } = require('../addon/window');
     // Load localization manifest and .properties files.
     // Run the addon even in case of error (best effort approach)
     require('../l10n/loader').
       load(rootURI).
-      then(null, function failure(error) {
+      catch(function failure(error) {
         if (!isNative)
           console.info("Error while loading localization: " + error.message);
       }).
       then(function onLocalizationReady(data) {
         // Exports data to a pseudo module so that api-utils/l10n/core
         // can get access to it
         definePseudo(options.loader, '@l10n/data', data ? data : null);
         return ready;
       }).then(function() {
         run(options);
-      }).then(null, console.exception);
+      }).catch(console.exception);
     return void 0; // otherwise we raise a warning, see bug 910304
   });
 }
 
 function run(options) {
   try {
     // Try initializing HTML localization before running main module. Just print
     // an exception in case of error, instead of preventing addon to be run.

--- a/addon-sdk/source/lib/sdk/l10n/loader.js
+++ b/addon-sdk/source/lib/sdk/l10n/loader.js
@@ -10,17 +10,17 @@ module.metadata = {
 const { Cc, Ci } = require("chrome");
 lazyRequire(this, "./locale", "getPreferedLocales", "findClosestLocale");
 lazyRequire(this, "../net/url", "readURI");
 lazyRequire(this, "../core/promise", "resolve");
 
 function parseJsonURI(uri) {
   return readURI(uri).
     then(JSON.parse).
-    then(null, function (error) {
+    catch(function (error) {
       throw Error("Failed to parse locale file:\n" + uri + "\n" + error);
     });
 }
 
 // Returns the array stored in `locales.json` manifest that list available
 // locales files
 function getAvailableLocales(rootURI) {
   let uri = rootURI + "locales.json";

--- a/addon-sdk/source/test/addons/page-mod-debugger-post/main.js
+++ b/addon-sdk/source/test/addons/page-mod-debugger-post/main.js
@@ -38,17 +38,17 @@ exports.testDebugger = function(assert, 
           then(_ => { assert.pass('attachTabActorForUrl called'); return _; }).
           then(attachThread).
           then(testDebuggerStatement).
           then(_ => { assert.pass('testDebuggerStatement called') }).
           then(closeConnection).
           then(_ => { assert.pass('closeConnection called') }).
           then(_ => { tab.close() }).
           then(done).
-          then(null, aError => {
+          catch(aError => {
             ok(false, "Got an error: " + aError.message + "\n" + aError.stack);
           });
       }
     });
   });
 }
 
 function attachThread([aGrip, aResponse]) {

--- a/addon-sdk/source/test/addons/page-mod-debugger-pre/main.js
+++ b/addon-sdk/source/test/addons/page-mod-debugger-pre/main.js
@@ -45,17 +45,17 @@ exports.testDebugger = function(assert, 
           then(_ => { assert.pass('attachTabActorForUrl called'); return _; }).
           then(attachThread).
           then(testDebuggerStatement).
           then(_ => { assert.pass('testDebuggerStatement called') }).
           then(closeConnection).
           then(_ => { assert.pass('closeConnection called') }).
           then(_ => { tab.close() }).
           then(done).
-          then(null, aError => {
+          catch(aError => {
             ok(false, "Got an error: " + aError.message + "\n" + aError.stack);
           });
       }
     });
   });
 }
 
 function attachThread([aGrip, aResponse]) {

--- a/addon-sdk/source/test/addons/places/lib/test-places-host.js
+++ b/addon-sdk/source/test/addons/places/lib/test-places-host.js
@@ -61,17 +61,17 @@ exports.testBookmarksCreateFail = functi
     type: 'bookmark'
   }, {
     type: 'group',
     group: bmsrv.bookmarksMenuFolder
   }, {
     group: bmsrv.unfiledBookmarksFolder
   }];
   all(items.map(function (item) {
-    return send('sdk-places-bookmarks-create', item).then(null, function (reason) {
+    return send('sdk-places-bookmarks-create', item).catch(function (reason) {
       assert.ok(reason, 'bookmark create should fail');
     });
   })).then(done);
 };
 
 exports.testBookmarkLastUpdated = function (assert, done) {
   let timestamp;
   let item;

--- a/addon-sdk/source/test/addons/private-browsing-supported/test-selection.js
+++ b/addon-sdk/source/test/addons/private-browsing-supported/test-selection.js
@@ -228,24 +228,24 @@ exports["test PWPB Selection Listener"] 
           assert.ok(isFocused(window), "the window is focused");
           assert.ok(isPrivate(window), "the window should be a private window");
 
           assert.equal(selection.text, "fo");
 
           closeWindow(window).
             then(loader.unload).
             then(done).
-            then(null, assert.fail);
+            catch(assert.fail);
         });
       });
       return window;
     }).
     then(selectContentFirstDiv).
     then(dispatchSelectionEvent).
-    then(null, assert.fail);
+    catch(assert.fail);
 };
 
 exports["test PWPB Textarea OnSelect Listener"] = function(assert, done) {
   let loader = Loader(module);
   let selection = loader.require("sdk/selection");
 
   open(URL, {private: true, title: "PWPB OnSelect Listener"}).
     then(function(window) {
@@ -258,24 +258,24 @@ exports["test PWPB Textarea OnSelect Lis
 
         // window should be focused, but force the focus anyhow.. see bug 841823
         focus(window).then(function() {
           assert.equal(selection.text, "noodles");
 
           closeWindow(window).
             then(loader.unload).
             then(done).
-            then(null, assert.fail);
+            catch(assert.fail);
         });
       });
       return window;
     }).
     then(selectTextarea).
     then(dispatchOnSelectEvent).
-    then(null, assert.fail);
+    catch(assert.fail);
 };
 
 exports["test PWPB Single DOM Selection"] = function(assert, done) {
   let loader = Loader(module);
   let selection = loader.require("sdk/selection");
 
   open(URL, {private: true, title: "PWPB Single DOM Selection"}).
     then(selectFirstDiv).
@@ -299,17 +299,17 @@ exports["test PWPB Single DOM Selection"
         assert.equal(sel.html, "<div>foo</div>",
           "iterable selection.html with single DOM Selection works.");
       }
 
       assert.equal(selectionCount, 1,
         "One iterable selection");
 
       return closeWindow(window);
-    }).then(loader.unload).then(done).then(null, assert.fail);
+    }).then(loader.unload).then(done).catch(assert.fail);
 }
 
 exports["test PWPB Textarea Selection"] = function(assert, done) {
   let loader = Loader(module);
   let selection = loader.require("sdk/selection");
 
   open(URL, {private: true, title: "PWPB Textarea Listener"}).
     then(selectTextarea).
@@ -335,17 +335,17 @@ exports["test PWPB Textarea Selection"] 
         assert.strictEqual(sel.html, null,
           "iterable selection.html with Textarea Selection works.");
       }
 
       assert.equal(selectionCount, 1,
         "One iterable selection");
 
       return closeWindow(window);
-    }).then(loader.unload).then(done).then(null, assert.fail);
+    }).then(loader.unload).then(done).catch(assert.fail);
 };
 
 exports["test PWPB Set HTML in Multiple DOM Selection"] = function(assert, done) {
   let loader = Loader(module);
   let selection = loader.require("sdk/selection");
 
   open(URL, {private: true, title: "PWPB Set HTML in Multiple DOM Selection"}).
     then(selectAllDivs).
@@ -375,17 +375,17 @@ exports["test PWPB Set HTML in Multiple 
 
         selectionCount++;
       }
 
       assert.equal(selectionCount, 2,
         "Two iterable selections");
 
       return closeWindow(window);
-    }).then(loader.unload).then(done).then(null, assert.fail);
+    }).then(loader.unload).then(done).catch(assert.fail);
 };
 
 exports["test PWPB Set Text in Textarea Selection"] = function(assert, done) {
   let loader = Loader(module);
   let selection = loader.require("sdk/selection");
 
   open(URL, {private: true, title: "test PWPB Set Text in Textarea Selection"}).
     then(selectTextarea).
@@ -412,17 +412,17 @@ exports["test PWPB Set Text in Textarea 
         assert.strictEqual(sel.html, null,
           "iterable selection.html with Textarea Selection works.");
       }
 
       assert.equal(selectionCount, 1,
         "One iterable selection");
 
       return closeWindow(window);
-    }).then(loader.unload).then(done).then(null, assert.fail);
+    }).then(loader.unload).then(done).catch(assert.fail);
 };
 
 // If the platform doesn't support the PBPW, we're replacing PBPW tests
 if (!require("sdk/private-browsing/utils").isWindowPBSupported) {
   module.exports = {
     "test PBPW Unsupported": function Unsupported (assert) {
       assert.pass("Private Window Per Browsing is not supported on this platform.");
     }

--- a/addon-sdk/source/test/addons/private-browsing-supported/test-sidebar.js
+++ b/addon-sdk/source/test/addons/private-browsing-supported/test-sidebar.js
@@ -35,17 +35,17 @@ exports.testSideBarIsInNewPrivateWindows
       assert.ok(isPrivate(window), 'the new window is private');
       assert.ok(!!ele, 'sidebar element was added');
 
       sidebar.destroy();
       assert.ok(!window.document.getElementById(makeID(testName)), 'sidebar id DNE');
       assert.ok(!startWindow.document.getElementById(makeID(testName)), 'sidebar id DNE');
 
       return close(window);
-  }).then(done).then(null, assert.fail);
+  }).then(done).catch(assert.fail);
 }
 
 // Disabled in order to land other fixes, see bug 910647 for further details.
 /*
 exports.testSidebarIsOpenInNewPrivateWindow = function(assert, done) {
   const { Sidebar } = require('sdk/ui/sidebar');
   let testName = 'testSidebarIsOpenInNewPrivateWindow';
   let window = getMostRecentBrowserWindow();
@@ -137,18 +137,18 @@ exports.testDestroyEdgeCaseBugWithPrivat
           assert.equal(isSidebarShowing(window), false, 'the sidebar is not showing');
 
           done();
         }
       })
 
       sidebar.show();
       assert.pass('showing the sidebar');
-    }).then(null, assert.fail);
-  }).then(null, assert.fail);
+    }).catch(assert.fail);
+  }).catch(assert.fail);
 }
 
 exports.testShowInPrivateWindow = function(assert, done) {
   const { Sidebar } = require('sdk/ui/sidebar');
   let testName = 'testShowInPrivateWindow';
   let window1 = getMostRecentBrowserWindow();
   let url = 'data:text/html;charset=utf-8,'+testName;
 
@@ -183,22 +183,22 @@ exports.testShowInPrivateWindow = functi
                   'the menuitem on the new window dne');
 
         // test old window state
         assert.equal(isSidebarShowing(window1), false, 'the old window sidebar is not showing');
         assert.equal(window1.document.getElementById(menuitemID),
                      null,
                      'the menuitem on the old window dne');
 
-        close(window).then(done).then(null, assert.fail);
+        close(window).then(done).catch(assert.fail);
       },
       function bad() {
         assert.fail('a successful show should not happen here..');
       });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }
 
 // If the module doesn't support the app we're being run in, require() will
 // throw.  In that case, remove all tests above from exports, and add one dummy
 // test that passes.
 try {
   require('sdk/ui/sidebar');
 }

--- a/addon-sdk/source/test/addons/private-browsing-supported/test-window-tabs.js
+++ b/addon-sdk/source/test/addons/private-browsing-supported/test-window-tabs.js
@@ -13,63 +13,63 @@ exports.testOpenTabWithPrivateActiveWind
 
   windowPromise(window, 'load').then(focus).then(function (window) {
     assert.ok(isPrivate(window), 'new window is private');
 
     tabs.open({
       url: 'about:blank',
       onOpen: function(tab) {
         assert.ok(isPrivate(tab), 'new tab is private');
-        close(window).then(done).then(null, assert.fail);
+        close(window).then(done).catch(assert.fail);
       }
     })
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }
 
 exports.testOpenTabWithNonPrivateActiveWindowNoIsPrivateOption = function(assert, done) {
   let window = getMostRecentBrowserWindow().OpenBrowserWindow({ private: false });
 
   windowPromise(window, 'load').then(focus).then(function (window) {
     assert.equal(isPrivate(window), false, 'new window is not private');
 
     tabs.open({
       url: 'about:blank',
       onOpen: function(tab) {
         assert.equal(isPrivate(tab), false, 'new tab is not private');
-        close(window).then(done).then(null, assert.fail);
+        close(window).then(done).catch(assert.fail);
       }
     })
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }
 
 exports.testOpenTabWithPrivateActiveWindowWithIsPrivateOptionTrue = function(assert, done) {
   let window = getMostRecentBrowserWindow().OpenBrowserWindow({ private: true });
 
   windowPromise(window, 'load').then(focus).then(function (window) {
     assert.ok(isPrivate(window), 'new window is private');
 
     tabs.open({
       url: 'about:blank',
       isPrivate: true,
       onOpen: function(tab) {
         assert.ok(isPrivate(tab), 'new tab is private');
-        close(window).then(done).then(null, assert.fail);
+        close(window).then(done).catch(assert.fail);
       }
     })
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }
 
 exports.testOpenTabWithNonPrivateActiveWindowWithIsPrivateOptionFalse = function(assert, done) {
   let window = getMostRecentBrowserWindow().OpenBrowserWindow({ private: false });
 
   windowPromise(window, 'load').then(focus).then(function (window) {
     assert.equal(isPrivate(window), false, 'new window is not private');
 
     tabs.open({
       url: 'about:blank',
       isPrivate: false,
       onOpen: function(tab) {
         assert.equal(isPrivate(tab), false, 'new tab is not private');
-        close(window).then(done).then(null, assert.fail);
+        close(window).then(done).catch(assert.fail);
       }
     })
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }

--- a/addon-sdk/source/test/addons/private-browsing-supported/test-windows.js
+++ b/addon-sdk/source/test/addons/private-browsing-supported/test-windows.js
@@ -69,17 +69,17 @@ exports.testWindowTrackerIgnoresPrivateW
       assert.pass('private window was closed');
 
       return makeEmptyBrowserWindow().then(function(window) {
         myNonPrivateWindowId = getInnerId(window);
         assert.notEqual(myPrivateWindowId, myNonPrivateWindowId, 'non private window was opened');
         return close(window);
       });
     });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 // Test setting activeWIndow and onFocus for private windows
 exports.testSettingActiveWindowDoesNotIgnorePrivateWindow = function(assert, done) {
   let browserWindow = WM.getMostRecentWindow("navigator:browser");
   let testSteps;
 
   assert.equal(winUtils.activeBrowserWindow, browserWindow,
@@ -141,17 +141,17 @@ exports.testSettingActiveWindowDoesNotIg
         continueAfterFocus(winUtils.activeWindow = browserWindow);
       },
       function() {
         assert.strictEqual(winUtils.activeBrowserWindow, browserWindow,
                           "Correct active browser window when pb mode is supported [4]");
         assert.strictEqual(winUtils.activeWindow, browserWindow,
                           "Correct active window when pb mode is supported [4]");
 
-        close(window).then(done).then(null, assert.fail);
+        close(window).then(done).catch(assert.fail);
       }
     ];
 
     function nextTest() {
       let args = arguments;
       if (testSteps.length) {
         require('sdk/timers').setTimeout(function() {
           (testSteps.shift()).apply(null, args);
@@ -231,10 +231,10 @@ exports.testWindowIteratorPrivateDefault
     assert.equal(isPrivate(winUtils.activeWindow), isWindowPBSupported);
     assert.equal(isPrivate(getMostRecentWindow()), isWindowPBSupported);
     assert.equal(isPrivate(browserWindows.activeWindow), isWindowPBSupported);
 
     assert.equal(browserWindows.length, 2, '2 windows open');
     assert.equal(windows(null, { includePrivate: true }).length, 2);
 
     return close(window);
-  }).then(done).then(null, assert.fail);
+  }).then(done).catch(assert.fail);
 };

--- a/addon-sdk/source/test/tabs/test-firefox-tabs.js
+++ b/addon-sdk/source/test/tabs/test-firefox-tabs.js
@@ -70,17 +70,17 @@ exports.testBrowserWindowCreationOnActiv
   tabs.once('activate', function onActivate(eventTab) {
     assert.ok(windows.activeWindow, "Is able to fetch activeWindow");
     gotActivate = true;
   });
 
   open().then(function(window) {
     assert.ok(gotActivate, "Received activate event");
     return close(window);
-  }).then(done).then(null, assert.fail);
+  }).then(done).catch(assert.fail);
 }
 
 // TEST: tab unloader
 exports.testAutomaticDestroyEventOpen = function(assert, done) {
   let called = false;
   let loader = Loader(module);
   let tabs2 = loader.require("sdk/tabs");
   tabs2.on('open', _ => called = true);
@@ -171,17 +171,17 @@ exports.testTabPropertiesInNewWindow = f
   });
 
   let tabs = loader.require('sdk/tabs');
   let { viewFor } = loader.require('sdk/view/core');
 
   let count = 0;
   function onReadyOrLoad (tab) {
     if (count++) {
-      close(getOwnerWindow(viewFor(tab))).then(done).then(null, assert.fail);
+      close(getOwnerWindow(viewFor(tab))).then(done).catch(assert.fail);
     }
   }
 
   let url = "data:text/html;charset=utf-8,<html><head><title>foo</title></head><body>foo</body></html>";
   tabs.open({
     inNewWindow: true,
     url: url,
     onReady: function(tab) {
@@ -264,17 +264,17 @@ exports.testTabContentTypeAndReload = fu
       url: url,
       onReady: function(tab) {
         if (tab.url === url) {
           assert.equal(tab.contentType, "text/html");
           tab.url = urlXML;
         }
         else {
           assert.equal(tab.contentType, "text/xml");
-          close(window).then(done).then(null, assert.fail);
+          close(window).then(done).catch(assert.fail);
         }
       }
     });
   });
 };
 
 // TEST: tabs iterator and length property
 exports.testTabsIteratorAndLength = function(assert, done) {
@@ -289,34 +289,34 @@ exports.testTabsIteratorAndLength = func
     tabs.open({
       url: url,
       onOpen: function(tab) {
         let count = 0;
         for (let t of tabs) count++;
         assert.equal(count, startCount + 3, "iterated tab count matches");
         assert.equal(startCount + 3, tabs.length, "iterated tab count matches length property");
 
-        close(window).then(done).then(null, assert.fail);
+        close(window).then(done).catch(assert.fail);
       }
     });
   });
 };
 
 // TEST: tab.url setter
 exports.testTabLocation = function(assert, done) {
   open().then(focus).then(function(window) {
     let url1 = "data:text/html;charset=utf-8,foo";
     let url2 = "data:text/html;charset=utf-8,bar";
 
     tabs.on('ready', function onReady(tab) {
       if (tab.url != url2)
         return;
       tabs.removeListener('ready', onReady);
       assert.pass("tab.load() loaded the correct url");
-      close(window).then(done).then(null, assert.fail);
+      close(window).then(done).catch(assert.fail);
     });
 
     tabs.open({
       url: url1,
       onOpen: function(tab) {
         tab.url = url2
       }
     });
@@ -360,20 +360,20 @@ exports.testTabMove = function(assert, d
     let url = "data:text/html;charset=utf-8,foo";
 
     tabs.open({
       url: url,
       onOpen: function(tab) {
         assert.equal(tab.index, 1, "tab index before move matches");
         tab.index = 0;
         assert.equal(tab.index, 0, "tab index after move matches");
-        close(window).then(done).then(null, assert.fail);
+        close(window).then(done).catch(assert.fail);
       }
     });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 exports.testIgnoreClosing = function*(assert) {
   let url = "data:text/html;charset=utf-8,foobar";
   let originalWindow = getMostRecentBrowserWindow();
 
   let window = yield open().then(focus);
 
@@ -476,17 +476,17 @@ exports.testOpenInNewWindow = function(a
 
       onFocus(newWindow).then(function() {
         assert.equal(getMostRecentBrowserWindow(), newWindow, "new window is active");
         assert.equal(tab.url, url, "URL of the new tab matches");
         assert.equal(newWindow.content.location, url, "URL of new tab in new window matches");
         assert.equal(tabs.activeTab.url, url, "URL of activeTab matches");
 
         return close(newWindow).then(done);
-      }).then(null, assert.fail);
+      }).catch(assert.fail);
     }
   });
 
 }
 
 // Test tab.open inNewWindow + onOpen combination
 exports.testOpenInNewWindowOnOpen = function(assert, done) {
   let startWindowCount = windows().length;
@@ -497,17 +497,17 @@ exports.testOpenInNewWindowOnOpen = func
     inNewWindow: true,
     onOpen: function(tab) {
       let newWindow = getOwnerWindow(viewFor(tab));
 
       onFocus(newWindow).then(function() {
         assert.equal(windows().length, startWindowCount + 1, "a new window was opened");
         assert.equal(getMostRecentBrowserWindow(), newWindow, "new window is active");
 
-        close(newWindow).then(done).then(null, assert.fail);
+        close(newWindow).then(done).catch(assert.fail);
       });
     }
   });
 };
 
 // TEST: onOpen event handler
 exports.testTabsEvent_onOpen = function(assert, done) {
   open().then(focus).then(window => {
@@ -520,21 +520,21 @@ exports.testTabsEvent_onOpen = function(
     };
     tabs.on('open', listener1);
 
     // add listener via collection add
     tabs.on('open', function listener2(tab) {
       assert.equal(++eventCount, 2, "both listeners notified");
       tabs.removeListener('open', listener1);
       tabs.removeListener('open', listener2);
-      close(window).then(done).then(null, assert.fail);
+      close(window).then(done).catch(assert.fail);
     });
 
     tabs.open(url);
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 // TEST: onClose event handler
 exports.testTabsEvent_onClose = function*(assert) {
   let window = yield open().then(focus);
   let url = "data:text/html;charset=utf-8,onclose";
   let eventCount = 0;
 
@@ -616,17 +616,17 @@ exports.testTabsEvent_onCloseWindow = fu
       onClose: endTest
     });
 
     tabs.open({
       url: "data:text/html;charset=utf-8,tab4",
       onOpen: testCasePossiblyLoaded,
       onClose: endTest
     });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }
 
 // TEST: onReady event handler
 exports.testTabsEvent_onReady = function(assert, done) {
   open().then(focus).then(window => {
     let url = "data:text/html;charset=utf-8,onready";
     let eventCount = 0;
 
@@ -640,17 +640,17 @@ exports.testTabsEvent_onReady = function
     tabs.on('ready', function listener2(tab) {
       assert.equal(++eventCount, 2, "both listeners notified");
       tabs.removeListener('ready', listener1);
       tabs.removeListener('ready', listener2);
       close(window).then(done);
     });
 
     tabs.open(url);
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 // TEST: onActivate event handler
 exports.testTabsEvent_onActivate = function(assert, done) {
   open().then(focus).then(window => {
     let url = "data:text/html;charset=utf-8,onactivate";
     let eventCount = 0;
 
@@ -660,21 +660,21 @@ exports.testTabsEvent_onActivate = funct
     };
     tabs.on('activate', listener1);
 
     // add listener via collection add
     tabs.on('activate', function listener2(tab) {
       assert.equal(++eventCount, 2, "both listeners notified");
       tabs.removeListener('activate', listener1);
       tabs.removeListener('activate', listener2);
-      close(window).then(done).then(null, assert.fail);
+      close(window).then(done).catch(assert.fail);
     });
 
     tabs.open(url);
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 // onDeactivate event handler
 exports.testTabsEvent_onDeactivate = function*(assert) {
   let window = yield open().then(focus);
 
   let url = "data:text/html;charset=utf-8,ondeactivate";
   let eventCount = 0;
@@ -721,21 +721,21 @@ exports.testTabsEvent_pinning = function
       tabs.removeListener('pinned', onPinned);
       assert.ok(tab.isPinned, "notified tab is pinned");
       tab.unpin();
     });
 
     tabs.on('unpinned', function onUnpinned(tab) {
       tabs.removeListener('unpinned', onUnpinned);
       assert.ok(!tab.isPinned, "notified tab is not pinned");
-      close(window).then(done).then(null, assert.fail);
+      close(window).then(done).catch(assert.fail);
     });
 
     tabs.open(url);
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 // TEST: per-tab event handlers
 exports.testPerTabEvents = function*(assert) {
   let window = yield open().then(focus);
   let eventCount = 0;
 
   let tab = yield new Promise(resolve => {
@@ -835,19 +835,19 @@ exports.testAttachOnMultipleDocuments = 
     });
 
     function checkEnd() {
       if (detachEventCount != 2)
         return;
 
       assert.pass("Got all detach events");
 
-      close(window).then(done).then(null, assert.fail);
+      close(window).then(done).catch(assert.fail);
     }
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }
 
 
 exports.testAttachWrappers = function (assert, done) {
   // Check that content script has access to wrapped values by default
   open().then(focus).then(window => {
     let document = "data:text/html;charset=utf-8,<script>var globalJSVar = true; " +
                    "                       document.getElementById = 3;</script>";
@@ -861,22 +861,22 @@ exports.testAttachWrappers = function (a
                          '  self.postMessage(!("globalJSVar" in window));' +
                          '  self.postMessage(typeof window.globalJSVar == "undefined");' +
                          '} catch(e) {' +
                          '  self.postMessage(e.message);' +
                          '}',
           onMessage: function (msg) {
             assert.equal(msg, true, "Worker has wrapped objects ("+count+")");
             if (count++ == 1)
-              close(window).then(done).then(null, assert.fail);
+              close(window).then(done).catch(assert.fail);
           }
         });
       }
     });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }
 
 /*
 // We do not offer unwrapped access to DOM since bug 601295 landed
 // See 660780 to track progress of unwrap feature
 exports.testAttachUnwrapped = function (assert, done) {
   // Check that content script has access to unwrapped values through unsafeWindow
   openBrowserWindow(function(window, browser) {
@@ -926,34 +926,34 @@ exports['test window focus changes activ
 
           function whenReady(tab) {
             assert.pass("activate was called on windows focus change.");
             assert.equal(tab.url, url1, 'the activated tab url is correct');
 
             return close(win2).then(function() {
               assert.pass('window 2 was closed');
               return close(win1);
-            }).then(done).then(null, assert.fail);
+            }).then(done).catch(assert.fail);
           }
         });
 
         win1.focus();
       });
     }, "data:text/html;charset=utf-8,test window focus changes active tab</br><h1>Window #2");
   }, url1);
 };
 
 exports['test ready event on new window tab'] = function(assert, done) {
   let uri = encodeURI("data:text/html;charset=utf-8,Waiting for ready event!");
 
   require("sdk/tabs").on("ready", function onReady(tab) {
     if (tab.url === uri) {
       require("sdk/tabs").removeListener("ready", onReady);
       assert.pass("ready event was emitted");
-      close(window).then(done).then(null, assert.fail);
+      close(window).then(done).catch(assert.fail);
     }
   });
 
   let window = openBrowserWindow(function(){}, uri);
 };
 
 exports['test unique tab ids'] = function(assert, done) {
   var windows = require('sdk/windows').browserWindows;

--- a/addon-sdk/source/test/test-addon-window.js
+++ b/addon-sdk/source/test/test-addon-window.js
@@ -11,12 +11,12 @@ exports.testReady = function(assert, don
   let windowIsReady = false;
 
   ready.then(function() {
     assert.equal(windowIsReady, false, 'ready promise was resolved only once');
     windowIsReady = true;
 
     loader.unload();
     done();
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }
 
 require('sdk/test').run(exports);

--- a/addon-sdk/source/test/test-child_process.js
+++ b/addon-sdk/source/test/test-child_process.js
@@ -61,17 +61,17 @@ exports.testExecOptionsEnvironment = fun
       env: { CHILD_PROCESS_ENV_TEST: 'my-value-test' }
     }, function (err, stdout, stderr) {
       assert.equal(stderr, '', 'stderr is empty');
       assert.ok(!err, 'received `cwd` option');
       assert.ok(/my-value-test/.test(stdout),
         'receives environment option');
       done();
     });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 exports.testExecOptionsTimeout = function (assert, done) {
   let count = 0;
   getScript('wait').then(script => {
     let child = exec(script, { timeout: 100 }, (err, stdout, stderr) => {
       assert.equal(err.killed, true, 'error has `killed` property as true');
       assert.equal(err.code, null, 'error has `code` as null');
@@ -99,29 +99,29 @@ exports.testExecOptionsTimeout = functio
     child.on('exit', exitHandler);
     child.on('close', closeHandler);
 
     function complete () {
       child.off('exit', exitHandler);
       child.off('close', closeHandler);
       done();
     }
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 exports.testExecFileCallbackSuccess = function (assert, done) {
   getScript('args').then(script => {
     execFile(script, ['--myargs', '-j', '-s'], { cwd: PROFILE_DIR }, function (err, stdout, stderr) {
       assert.ok(!err, 'no errors found');
       assert.equal(stderr, '', 'stderr is empty');
       // Trim output since different systems have different new line output
       assert.equal(stdout.trim(), '--myargs -j -s'.trim(), 'passes in correct arguments');
       done();
     });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 exports.testExecFileCallbackError = function (assert, done) {
   execFile('not-real-command', { cwd: PROFILE_DIR }, function (err, stdout, stderr) {
     assert.ok(/Executable not found/.test(err.message),
       `error '${err.message}' contains error message`);
     assert.ok(err.lineNumber >= 0, 'error contains lineNumber');
     assert.ok(/resource:\/\//.test(err.fileName), 'error contains fileName');
@@ -138,17 +138,17 @@ exports.testExecFileOptionsEnvironment =
       env: { CHILD_PROCESS_ENV_TEST: 'my-value-test' }
     }, function (err, stdout, stderr) {
       assert.equal(stderr, '', 'stderr is empty');
       assert.ok(!err, 'received `cwd` option');
       assert.ok(/my-value-test/.test(stdout),
         'receives environment option');
       done();
     });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 exports.testExecFileOptionsTimeout = function (assert, done) {
   let count = 0;
   getScript('wait').then(script => {
     let child = execFile(script, { timeout: 100 }, (err, stdout, stderr) => {
       assert.equal(err.killed, true, 'error has `killed` property as true');
       assert.equal(err.code, null, 'error has `code` as null');
@@ -176,17 +176,17 @@ exports.testExecFileOptionsTimeout = fun
     child.on('exit', exitHandler);
     child.on('close', closeHandler);
 
     function complete () {
       child.off('exit', exitHandler);
       child.off('close', closeHandler);
       done();
     }
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 /**
  * Not necessary to test for both `exec` and `execFile`, but
  * it is necessary to test both when the buffer is larger
  * and smaller than buffer size used by the subprocess library (1024)
  */
 exports.testExecFileOptionsMaxBufferLargeStdOut = function (assert, done) {
@@ -199,17 +199,17 @@ exports.testExecFileOptionsMaxBufferLarg
       assert.ok(/stdout maxBuffer exceeded/.test(err.toString()),
         'error contains stdout maxBuffer exceeded message');
       assert.ok(stdout.length >= 50, 'stdout has full buffer');
       assert.equal(stderr, '', 'stderr is empty');
       if (++count === 3) complete();
     });
     stdoutChild.on('exit', exitHandler);
     stdoutChild.on('close', closeHandler);
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 
   function exitHandler (code, signal) {
     assert.equal(code, null, 'Exit code is null in exit handler');
     assert.equal(signal, 'SIGTERM', 'Signal is SIGTERM in exit handler');
     if (++count === 3) complete();
   }
 
   function closeHandler (code, signal) {
@@ -234,17 +234,17 @@ exports.testExecFileOptionsMaxBufferLarg
       assert.ok(/stderr maxBuffer exceeded/.test(err.toString()),
         'error contains stderr maxBuffer exceeded message');
       assert.ok(stderr.length >= 50, 'stderr has full buffer');
       assert.equal(stdout, '', 'stdout is empty');
       if (++count === 3) complete();
     });
     stderrChild.on('exit', exitHandler);
     stderrChild.on('close', closeHandler);
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 
   function exitHandler (code, signal) {
     assert.equal(code, null, 'Exit code is null in exit handler');
     assert.equal(signal, 'SIGTERM', 'Signal is SIGTERM in exit handler');
     if (++count === 3) complete();
   }
 
   function closeHandler (code, signal) {
@@ -275,17 +275,17 @@ exports.testExecFileOptionsMaxBufferSmal
       assert.ok(/stdout maxBuffer exceeded/.test(err.toString()),
         'error contains stdout maxBuffer exceeded message');
       assert.ok(stdout.length >= 50, 'stdout has full buffer');
       assert.equal(stderr, '', 'stderr is empty');
       if (++count === 3) complete();
     });
     stdoutChild.on('exit', exitHandler);
     stdoutChild.on('close', closeHandler);
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 
   function exitHandler (code, signal) {
     // Sometimes the buffer limit is hit before the process closes successfully
     // on both OSX/Windows
     if (code === null) {
       assert.equal(code, null, 'Exit code is null in exit handler');
       assert.equal(signal, 'SIGTERM', 'Signal is SIGTERM in exit handler');
     }
@@ -326,17 +326,17 @@ exports.testExecFileOptionsMaxBufferSmal
       assert.ok(/stderr maxBuffer exceeded/.test(err.toString()),
         'error contains stderr maxBuffer exceeded message');
       assert.ok(stderr.length >= 50, 'stderr has full buffer');
       assert.equal(stdout, '', 'stdout is empty');
       if (++count === 3) complete();
     });
     stderrChild.on('exit', exitHandler);
     stderrChild.on('close', closeHandler);
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 
   function exitHandler (code, signal) {
     // Sometimes the buffer limit is hit before the process closes successfully
     // on both OSX/Windows
     if (code === null) {
       assert.equal(code, null, 'Exit code is null in exit handler');
       assert.equal(signal, 'SIGTERM', 'Signal is SIGTERM in exit handler');
     }
@@ -372,17 +372,17 @@ exports.testChildExecFileKillSignal = fu
   getScript('wait').then(script => {
     execFile(script, {
       killSignal: 'beepbeep',
       timeout: 10
     }, function (err, stdout, stderr) {
       assert.equal(err.signal, 'beepbeep', 'correctly used custom killSignal');
       done();
     });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 exports.testChildProperties = function (assert, done) {
   getScript('check-env').then(script => {
     let child = spawn(script, {
       env: { CHILD_PROCESS_ENV_TEST: 'my-value-test' }
     });
 
@@ -503,17 +503,17 @@ exports.testSpawnOptions = function (ass
     cwdChild = spawn(checkPwd, { cwd: PROFILE_DIR });
 
     // Do these need to be unbound?
     envChild.stdout.on('data', data => envStdout += data);
     cwdChild.stdout.on('data', data => cwdStdout += data);
 
     envChild.on('close', envClose);
     cwdChild.on('close', cwdClose);
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 
   function envClose () {
     assert.equal(envStdout.trim(), 'my-value-test', 'spawn correctly passed in ENV');
     if (++count === 2) complete();
   }
 
   function cwdClose () {
     // Check for PROFILE_DIR in the output because

--- a/addon-sdk/source/test/test-native-loader.js
+++ b/addon-sdk/source/test/test-native-loader.js
@@ -232,17 +232,17 @@ for (let variant of variants) {
         manifest: manifest,
         isNative: true
       });
 
       let program = main(loader);
       testLoader(program, assert);
       unload(loader);
       done();
-    }).then(null, (reason) => console.error(reason));
+    }).catch((reason) => console.error(reason));
   };
 
   exports[`test require#resolve with relative, dependencies (${variant.description})`] = function(assert, done) {
     getJSON('/fixtures/native-addon-test/package.json').then(manifest => {
       let rootURI = variant.getRootURI('native-addon-test');
       let loader = Loader({
         paths: makePaths(rootURI),
         rootURI: rootURI,
@@ -260,17 +260,17 @@ for (let variant of variants) {
       assert.equal(program.require.resolve("modules/Promise.jsm"), "resource://gre/modules/Promise.jsm", "works with path lookups");
 
       // TODO bug 1050422, handle loading non JS/JSM file paths
       // assert.equal(program.require.resolve("test-assets/styles.css"), fixtureRoot + "node_modules/test-assets/styles.css",
       // "works with different file extension lookups in dependencies");
 
       unload(loader);
       done();
-    }).then(null, (reason) => console.error(reason));
+    }).catch((reason) => console.error(reason));
   };
 }
 
 before(exports, () => {
   for (let fixture of fixtures) {
     let url = `jar:${root}/fixtures/${fixture}.xpi!/`;
 
     resProto.setSubstitution(fixture, NetUtil.newURI(url));
@@ -304,17 +304,17 @@ exports['test JSM loading'] = function (
       program.isLoadedAbsolute(20),
       program.isLoadedJSAbsolute(30)
     ]).then(([path, absolute, jsabsolute]) => {
       assert.equal(path, 10, 'JSM files resolved from path work');
       assert.equal(absolute, 20, 'JSM files resolved from full resource:// work');
       assert.equal(jsabsolute, 30, 'JS files resolved from full resource:// work');
     }).then(done, console.error);
 
-  }).then(null, console.error);
+  }).catch(console.error);
 };
 
 function testLoader (program, assert) {
   // Test 'main' entries
   // no relative custom main `lib/index.js`
   assert.equal(program.customMainModule, 'custom entry file',
     'a node_module dependency correctly uses its `main` entry in manifest');
   // relative custom main `./lib/index.js`
@@ -383,12 +383,12 @@ function loadAddon (uri, map) {
       rootURI: rootURI,
       manifest: manifest,
       isNative: true,
       modules: {
         '@test/options': testOptions
       }
     });
     let program = main(loader);
-  }).then(null, console.error);
+  }).catch(console.error);
 }
 
 require('sdk/test').run(exports);

--- a/addon-sdk/source/test/test-panel.js
+++ b/addon-sdk/source/test/test-panel.js
@@ -1016,17 +1016,17 @@ exports['test panel CSS'] = function(ass
       assert.equal(div.offsetHeight, 120,
         "Panel contentStyleFile worked");
 
       assert.equal(window.getComputedStyle(div).borderTopStyle, "dashed",
         "Panel contentStyleFile with relative path worked");
 
         loader.unload();
         done();
-      }).then(null, assert.fail);
+      }).catch(assert.fail);
     }
   });
 
   panel.show();
 };
 
 exports['test panel contentScriptFile'] = function(assert, done) {
   const { merge } = require("sdk/util/object");

--- a/addon-sdk/source/test/test-promise.js
+++ b/addon-sdk/source/test/test-promise.js
@@ -112,22 +112,22 @@ exports['test error recovery with promis
     let deferred = defer();
     deferred.resolve('recovery');
     return deferred.promise;
   }).then(function(actual) {
     assert.equal(actual, 'recovery', 'recorvered via promise');
     let deferred = defer();
     deferred.reject('error');
     return deferred.promise;
-  }).then(null, function(actual) {
+  }).catch(function(actual) {
     assert.equal(actual, 'error', 'rejected via promise');
     let deferred = defer();
     deferred.reject('end');
     return deferred.promise;
-  }).then(null, function(actual) {
+  }).catch(function(actual) {
     assert.equal(actual, 'end', 'rejeced via promise');
     done();
   });
 
   deferred.reject('reason');
 };
 
 exports['test propagation'] = function(assert, done) {
@@ -145,27 +145,27 @@ exports['test propagation'] = function(a
 
 exports['test chaining'] = function(assert, done) {
   let boom = Error('boom'), brax = Error('braxXXx');
   let deferred = defer();
 
   deferred.promise.then().then().then(function(actual) {
     assert.equal(actual, 2, 'value propagates unchanged');
     return actual + 2;
-  }).then(null, function(reason) {
+  }).catch(function(reason) {
     assert.fail('should not reject');
   }).then(function(actual) {
     assert.equal(actual, 4, 'value propagates through if not handled');
     throw boom;
   }).then(function(actual) {
     assert.fail('exception must reject promise');
-  }).then().then(null, function(actual) {
+  }).then().catch(function(actual) {
     assert.equal(actual, boom, 'reason propagates unchanged');
     throw brax;
-  }).then().then(null, function(actual) {
+  }).then().catch(function(actual) {
     assert.equal(actual, brax, 'reason changed becase of exception');
     return 'recovery';
   }).then(function(actual) {
     assert.equal(actual, 'recovery', 'recovered from error');
     done();
   });
 
   deferred.resolve(2);
@@ -236,17 +236,17 @@ exports['test promised error handling'] 
 exports['test errors in promise resolution handlers are propagated'] = function(assert, done) {
   var expected = Error('Boom');
   var { promise, resolve } = defer();
 
   promise.then(function() {
     throw expected;
   }).then(function() {
     return undefined;
-  }).then(null, function(actual) {
+  }).catch(function(actual) {
     assert.equal(actual, expected, 'rejected as expected');
   }).then(done, assert.fail);
 
   resolve({});
 };
 
 exports['test return promise form promised'] = function(assert, done) {
   let f = promised(function() {
@@ -440,17 +440,17 @@ function testEnvironment ({all, resolve,
   all([resolve(5), resolve(10), 925]).then(val => {
     assert.equal(val[0], 5, 'promise#all works ' + type);
     assert.equal(val[1], 10, 'promise#all works ' + type);
     assert.equal(val[2], 925, 'promise#all works ' + type);
     return resolve(1000);
   }).then(value => {
     assert.equal(value, 1000, 'promise#resolve works ' + type);
     return reject('testing reject');
-  }).then(null, reason => {
+  }).catch(reason => {
     assert.equal(reason, 'testing reject', 'promise#reject works ' + type);
     let deferred = defer();
     setTimeout(() => deferred.resolve('\\m/'), 10);
     return deferred.promise;
   }).then(value => {
     assert.equal(value, '\\m/', 'promise#defer works ' + type);
     return promised(x => x * x)(5);
   }).then(value => {

--- a/addon-sdk/source/test/test-ui-toggle-button.js
+++ b/addon-sdk/source/test/test-ui-toggle-button.js
@@ -1200,17 +1200,17 @@ exports['test button checked'] = functio
           'clicked:foo', 'changed:foo:false', 'clicked:foo', 'changed:foo:true'
         ],
         'button change events works');
 
       close(window).
         then(loader.unload).
         then(done, assert.fail);
     })
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 }
 
 exports['test button is checked on window level'] = function(assert, done) {
   let loader = Loader(module);
   let { ToggleButton } = loader.require('sdk/ui');
   let { browserWindows } = loader.require('sdk/windows');
   let tabs = loader.require('sdk/tabs');
 
@@ -1262,17 +1262,17 @@ exports['test button is checked on windo
           'window state, checked is `false`.');
 
         tab.close(()=> {
           close(window).
             then(loader.unload).
             then(done, assert.fail);
         })
       }).
-      then(null, assert.fail);
+      catch(assert.fail);
     }
   });
 
 };
 
 exports['test button click do not messing up states'] = function(assert) {
   let loader = Loader(module);
   let { ToggleButton } = loader.require('sdk/ui');

--- a/addon-sdk/source/test/test-window-utils-private-browsing.js
+++ b/addon-sdk/source/test/test-window-utils-private-browsing.js
@@ -74,17 +74,17 @@ exports.testWindowTrackerIgnoresPrivateW
 
     return close(window).then(function() {
       return makeEmptyBrowserWindow().then(function(window) {
         myNonPrivateWindow = window;
         assert.pass('opened new window');
         return close(window);
       });
     });
-  }).then(null, assert.fail);
+  }).catch(assert.fail);
 };
 
 // Test setting activeWIndow and onFocus for private windows
 exports.testSettingActiveWindowDoesNotIgnorePrivateWindow = function(assert, done) {
   let browserWindow = WM.getMostRecentWindow("navigator:browser");
 
   assert.equal(windowUtils.activeBrowserWindow, browserWindow,
                "Browser window is the active browser window.");
@@ -137,17 +137,17 @@ exports.testSettingActiveWindowDoesNotIg
     }).then(_ => {
       assert.strictEqual(windowUtils.activeBrowserWindow, browserWindow,
                          "Correct active browser window when pb mode is supported [4]");
       assert.strictEqual(windowUtils.activeWindow, browserWindow,
                          "Correct active window when pb mode is supported [4]");
 
       return close(window);
     })
-  }).then(done).then(null, assert.fail);
+  }).then(done).catch(assert.fail);
 };
 
 exports.testActiveWindowDoesNotIgnorePrivateWindow = function(assert, done) {
   // make a new private window
   makeEmptyBrowserWindow({
     private: true
   }).then(function(window) {
     // PWPB case
@@ -177,17 +177,17 @@ exports.testActiveWindowDoesNotIgnorePri
                    "active window is not private");
       assert.equal(isPrivate(windowUtils.activeBrowserWindow), false,
                    "active browser window is not private");
       assert.equal(isWindowPrivate(window), false, "window is not private");
       assert.equal(isPrivate(window), false, "window is not private");
     }
 
     return close(window);
-  }).then(done).then(null, assert.fail);
+  }).then(done).catch(assert.fail);
 }
 
 exports.testWindowIteratorIgnoresPrivateWindows = function(assert, done) {
   // make a new private window
   makeEmptyBrowserWindow({
     private: true
   }).then(function(window) {
     // PWPB case
@@ -199,12 +199,12 @@ exports.testWindowIteratorIgnoresPrivate
     // Global case
     else {
       assert.equal(isWindowPrivate(window), false, "window is not private");
       assert.ok(toArray(windowUtils.windowIterator()).indexOf(window) > -1,
                 "window is in windowIterator()");
     }
 
     return close(window);
-  }).then(done).then(null, assert.fail);
+  }).then(done).catch(assert.fail);
 };
 
 require("sdk/test").run(exports);

--- a/browser/base/content/aboutaccounts/aboutaccounts.js
+++ b/browser/base/content/aboutaccounts/aboutaccounts.js
@@ -440,31 +440,31 @@ function migrateToDevEdition(urlParams) 
     let accountData = JSON.parse(text).accountData;
     updateDisplayedEmail(accountData);
     return fxAccounts.setSignedInUser(accountData);
   }).then(() => {
     return fxAccounts.promiseAccountsForceSigninURI().then(url => {
       show("remote");
       wrapper.init(url, urlParams);
     });
-  }).then(null, error => {
+  }).catch(error => {
     log("Failed to migrate FX Account: " + error);
     show("stage", "intro");
     // load the remote frame in the background
     fxAccounts.promiseAccountsSignUpURI().then(uri => {
       wrapper.init(uri, urlParams)
     }).catch(e => {
       console.log("Failed to load signup page", e);
       setErrorPage("configError");
     });
   }).then(() => {
     // Reset the pref after migration.
     Services.prefs.setBoolPref("identity.fxaccounts.migrateToDevEdition", false);
     return true;
-  }).then(null, err => {
+  }).catch(err => {
     Cu.reportError("Failed to reset the migrateToDevEdition pref: " + err);
     return false;
   });
 }
 
 // Helper function that returns the path of the default profile on disk. Will be
 // overridden in tests.
 function getDefaultProfilePath() {

--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -1669,17 +1669,17 @@ var gBrowserInit = {
       Cu.reportError("Could not end startup crash tracking: " + ex);
     }
 
     // Delay this a minute into the idle time because there's no rush.
     requestIdleCallback(() => {
       this.gmpInstallManager = new GMPInstallManager();
       // We don't really care about the results, if someone is interested they
       // can check the log.
-      this.gmpInstallManager.simpleCheckAndInstall().then(null, () => {});
+      this.gmpInstallManager.simpleCheckAndInstall().catch(() => {});
     }, {timeout: 1000 * 60});
 
     SessionStore.promiseInitialized.then(() => {
       // Bail out if the window has been closed in the meantime.
       if (window.closed) {
         return;
       }
 

--- a/browser/base/content/sanitizeDialog.js
+++ b/browser/base/content/sanitizeDialog.js
@@ -98,19 +98,19 @@ var gSanitizePromptDialog = {
     let docElt = document.documentElement;
     let acceptButton = docElt.getButton("accept");
     acceptButton.disabled = true;
     acceptButton.setAttribute("label",
                               this.bundleBrowser.getString("sanitizeButtonClearing"));
     docElt.getButton("cancel").disabled = true;
 
     try {
-      s.sanitize().then(null, Components.utils.reportError)
+      s.sanitize().catch(Components.utils.reportError)
                   .then(() => window.close())
-                  .then(null, Components.utils.reportError);
+                  .catch(Components.utils.reportError);
       return false;
     } catch (er) {
       Components.utils.reportError("Exception during sanitize: " + er);
       return true; // We *do* want to close immediately on error.
     }
   },
 
   /**

--- a/browser/components/customizableui/CustomizeMode.jsm
+++ b/browser/components/customizableui/CustomizeMode.jsm
@@ -421,17 +421,17 @@ CustomizeMode.prototype = {
           this.panelUIContents.setAttribute("showoutline", "true");
         }
         delete this._enableOutlinesTimeout;
       }, 0);
 
       if (!this._wantToBeInCustomizeMode) {
         this.exit();
       }
-    })().then(null, e => {
+    })().catch(e => {
       log.error("Error entering customize mode", e);
       // We should ensure this has been called, and calling it again doesn't hurt:
       window.PanelUI.endBatchUpdate();
       this._handler.isEnteringCustomizeMode = false;
       // Exit customize mode to ensure proper clean-up when entering failed.
       this.exit();
     });
   },
@@ -591,17 +591,17 @@ CustomizeMode.prototype = {
       this._transitioning = false;
       this._handler.isExitingCustomizeMode = false;
       CustomizableUI.dispatchToolboxEvent("aftercustomization", {}, window);
       CustomizableUI.notifyEndCustomizing(window);
 
       if (this._wantToBeInCustomizeMode) {
         this.enter();
       }
-    })().then(null, e => {
+    })().catch(e => {
       log.error("Error exiting customize mode", e);
       if (!gPhotonStructure) {
         // We should ensure this has been called, and calling it again doesn't hurt:
         window.PanelUI.endBatchUpdate();
       }
       this._handler.isExitingCustomizeMode = false;
     });
   },
@@ -861,17 +861,17 @@ CustomizeMode.prototype = {
         } else if (provider == CustomizableUI.PROVIDER_SPECIAL) {
           this.visiblePalette.removeChild(paletteChild);
         }
 
         paletteChild = nextChild;
       }
       this.visiblePalette.hidden = false;
       this.window.gNavToolbox.palette = this._stowedPalette;
-    })().then(null, log.error);
+    })().catch(log.error);
   },
 
   isCustomizableItem(aNode) {
     return aNode.localName == "toolbarbutton" ||
            aNode.localName == "toolbaritem" ||
            aNode.localName == "toolbarseparator" ||
            aNode.localName == "toolbarspring" ||
            aNode.localName == "toolbarspacer";
@@ -1067,17 +1067,17 @@ CustomizeMode.prototype = {
     let target = CustomizableUI.getCustomizeTargetForArea(aArea, this.window);
     if (!target || this.areas.has(target)) {
       return null;
     }
 
     this._addDragHandlers(target);
     for (let child of target.children) {
       if (this.isCustomizableItem(child) && !this.isWrappedToolbarItem(child)) {
-        await this.deferredWrapToolbarItem(child, CustomizableUI.getPlaceForItem(child)).then(null, log.error);
+        await this.deferredWrapToolbarItem(child, CustomizableUI.getPlaceForItem(child)).catch(log.error);
       }
     }
     this.areas.add(target);
     return target;
   },
 
   _wrapToolbarItemSync(aArea) {
     let target = CustomizableUI.getCustomizeTargetForArea(aArea, this.window);
@@ -1144,17 +1144,17 @@ CustomizeMode.prototype = {
         for (let toolbarItem of target.children) {
           if (this.isWrappedToolbarItem(toolbarItem)) {
             await this.deferredUnwrapToolbarItem(toolbarItem);
           }
         }
         this._removeDragHandlers(target);
       }
       this.areas.clear();
-    })().then(null, log.error);
+    })().catch(log.error);
   },
 
   _removeExtraToolbarsIfEmpty() {
     let toolbox = this.window.gNavToolbox;
     for (let child of toolbox.children) {
       if (child.hasAttribute("customindex")) {
         let placements = CustomizableUI.getWidgetIdsInArea(child.id);
         if (!placements.length) {
@@ -1200,17 +1200,17 @@ CustomizeMode.prototype = {
       this._updateResetButton();
       this._updateUndoResetButton();
       this._updateEmptyPaletteNotice();
       this._showPanelCustomizationPlaceholders();
       this.resetting = false;
       if (!this._wantToBeInCustomizeMode) {
         this.exit();
       }
-    })().then(null, log.error);
+    })().catch(log.error);
   },
 
   undoReset() {
     this.resetting = true;
 
     return (async () => {
       this._removePanelCustomizationPlaceholders();
       await this.depopulatePalette();
@@ -1224,17 +1224,17 @@ CustomizeMode.prototype = {
       this.populatePalette();
 
       this.persistCurrentSets(true);
 
       this._updateResetButton();
       this._updateUndoResetButton();
       this._updateEmptyPaletteNotice();
       this.resetting = false;
-    })().then(null, log.error);
+    })().catch(log.error);
   },
 
   _onToolbarVisibilityChange(aEvent) {
     let toolbar = aEvent.target;
     if (aEvent.detail.visible && toolbar.getAttribute("customizable") == "true") {
       toolbar.setAttribute("customizing", "true");
     } else {
       toolbar.removeAttribute("customizing");

--- a/browser/components/customizableui/content/panelUI.js
+++ b/browser/components/customizableui/content/panelUI.js
@@ -439,17 +439,17 @@ const PanelUI = {
           CustomizableUI.registerMenuPanel(this.contents, CustomizableUI.AREA_PANEL);
         } finally {
           this.endBatchUpdate();
         }
       }
       this._updateQuitTooltip();
       this.panel.hidden = false;
       this._isReady = true;
-    })().then(null, Cu.reportError);
+    })().catch(Cu.reportError);
 
     return this._readyPromise;
   },
 
   /**
    * Switch the panel to the main view if it's not already
    * in that view.
    */

--- a/browser/components/downloads/DownloadsCommon.jsm
+++ b/browser/components/downloads/DownloadsCommon.jsm
@@ -462,17 +462,17 @@ this.DownloadsCommon = {
         aFile.launch();
       } catch (ex) {
         // If launch fails, try sending it through the system's external "file:"
         // URL handler.
         Cc["@mozilla.org/uriloader/external-protocol-service;1"]
           .getService(Ci.nsIExternalProtocolService)
           .loadUrl(NetUtil.newURI(aFile));
       }
-    }).then(null, Cu.reportError);
+    }).catch(Cu.reportError);
   },
 
   /**
    * Show a downloaded file in the system file manager.
    *
    * @param aFile
    *        a downloaded file.
    */
@@ -669,17 +669,17 @@ function DownloadsDataCtor(aPrivate) {
 DownloadsDataCtor.prototype = {
   /**
    * Starts receiving events for current downloads.
    */
   initializeDataLink() {
     if (!this._dataLinkInitialized) {
       let promiseList = Downloads.getList(this._isPrivate ? Downloads.PRIVATE
                                                           : Downloads.PUBLIC);
-      promiseList.then(list => list.addView(this)).then(null, Cu.reportError);
+      promiseList.then(list => list.addView(this)).catch(Cu.reportError);
       this._dataLinkInitialized = true;
     }
   },
   _dataLinkInitialized: false,
 
   /**
    * Iterator for all the available Download objects. This is empty until the
    * data has been loaded using the JavaScript API for downloads.
@@ -703,17 +703,17 @@ DownloadsDataCtor.prototype = {
 
   /**
    * Asks the back-end to remove finished downloads from the list.
    */
   removeFinished() {
     let promiseList = Downloads.getList(this._isPrivate ? Downloads.PRIVATE
                                                         : Downloads.PUBLIC);
     promiseList.then(list => list.removeFinished())
-               .then(null, Cu.reportError);
+               .catch(Cu.reportError);
     let indicatorData = this._isPrivate ? PrivateDownloadsIndicatorData
                                         : DownloadsIndicatorData;
     indicatorData.attention = DownloadsCommon.ATTENTION_NONE;
   },
 
   // Integration with the asynchronous Downloads back-end
 
   onDownloadAdded(download) {

--- a/browser/components/downloads/DownloadsTaskbar.jsm
+++ b/browser/components/downloads/DownloadsTaskbar.jsm
@@ -105,17 +105,17 @@ this.DownloadsTaskbar = {
       Downloads.getSummary(Downloads.ALL).then(summary => {
         // In case the method is re-entered, we simply ignore redundant
         // invocations of the callback, instead of keeping separate state.
         if (this._summary) {
           return undefined;
         }
         this._summary = summary;
         return this._summary.addView(this);
-      }).then(null, Cu.reportError);
+      }).catch(Cu.reportError);
     }
   },
 
   /**
    * On Windows, attaches the taskbar indicator to the specified browser window.
    */
   _attachIndicator(aWindow) {
     // Activate the indicator on the specified window.

--- a/browser/components/nsBrowserGlue.js
+++ b/browser/components/nsBrowserGlue.js
@@ -1176,17 +1176,17 @@ BrowserGlue.prototype = {
       if (willPrompt) {
         Services.tm.dispatchToMainThread(function() {
           DefaultBrowserCheck.prompt(RecentWindow.getMostRecentBrowserWindow());
         });
       }
     }
 
     // Let's load the contextual identities.
-    Services.tm.mainThread.idleDispatch(() => {
+    Services.tm.idleDispatchToMainThread(() => {
       ContextualIdentityService.load();
     });
 
     this._sanitizer.onStartup();
     E10SAccessibilityCheck.onWindowsRestored();
   },
 
   _createExtraDefaultProfile() {
@@ -1211,17 +1211,17 @@ BrowserGlue.prototype = {
       }
       if (newProfile) {
         // We don't want a default profile with Developer Edition settings, an
         // empty profile directory will do. The profile service of the other
         // Firefox will populate it with its own stuff.
         let newProfilePath = newProfile.rootDir.path;
         OS.File.removeDir(newProfilePath).then(() => {
           return OS.File.makeDir(newProfilePath);
-        }).then(null, e => {
+        }).catch(e => {
           Cu.reportError("Could not empty profile 'default': " + e);
         });
       }
     }
   },
 
   _onQuitRequest: function BG__onQuitRequest(aCancelQuit, aQuitType) {
     // If user has already dismissed quit request, then do nothing

--- a/browser/components/places/content/browserPlacesViews.js
+++ b/browser/components/places/content/browserPlacesViews.js
@@ -1637,17 +1637,17 @@ PlacesToolbar.prototype = {
   },
 
   _onDrop: function PT__onDrop(aEvent) {
     PlacesControllerDragHelper.currentDropTarget = aEvent.target;
 
     let dropPoint = this._getDropPoint(aEvent);
     if (dropPoint && dropPoint.ip) {
       PlacesControllerDragHelper.onDrop(dropPoint.ip, aEvent.dataTransfer)
-                                .then(null, Components.utils.reportError);
+                                .catch(Components.utils.reportError);
       aEvent.preventDefault();
     }
 
     this._cleanupDragDetails();
     aEvent.stopPropagation();
   },
 
   _onDragExit: function PT__onDragExit(aEvent) {

--- a/browser/components/places/content/controller.js
+++ b/browser/components/places/content/controller.js
@@ -212,40 +212,40 @@ PlacesController.prototype = {
 
   doCommand: function PC_doCommand(aCommand) {
     switch (aCommand) {
     case "cmd_undo":
       if (!PlacesUIUtils.useAsyncTransactions) {
         PlacesUtils.transactionManager.undoTransaction();
         return;
       }
-      PlacesTransactions.undo().then(null, Components.utils.reportError);
+      PlacesTransactions.undo().catch(Components.utils.reportError);
       break;
     case "cmd_redo":
       if (!PlacesUIUtils.useAsyncTransactions) {
         PlacesUtils.transactionManager.redoTransaction();
         return;
       }
-      PlacesTransactions.redo().then(null, Components.utils.reportError);
+      PlacesTransactions.redo().catch(Components.utils.reportError);
       break;
     case "cmd_cut":
     case "placesCmd_cut":
       this.cut();
       break;
     case "cmd_copy":
     case "placesCmd_copy":
       this.copy();
       break;
     case "cmd_paste":
     case "placesCmd_paste":
-      this.paste().then(null, Components.utils.reportError);
+      this.paste().catch(Components.utils.reportError);
       break;
     case "cmd_delete":
     case "placesCmd_delete":
-      this.remove("Remove Selection").then(null, Components.utils.reportError);
+      this.remove("Remove Selection").catch(Components.utils.reportError);
       break;
     case "placesCmd_deleteDataHost":
       var host;
       if (PlacesUtils.nodeIsHost(this._view.selectedNode)) {
         var queries = this._view.selectedNode.getQueries();
         host = queries[0].domain;
       } else
         host = NetUtil.newURI(this._view.selectedNode.uri).host;
@@ -281,17 +281,17 @@ PlacesController.prototype = {
       break;
     case "placesCmd_moveBookmarks":
       this.moveSelectedBookmarks();
       break;
     case "placesCmd_reload":
       this.reloadSelectedLivemark();
       break;
     case "placesCmd_sortBy:name":
-      this.sortFolderByName().then(null, Components.utils.reportError);
+      this.sortFolderByName().catch(Components.utils.reportError);
       break;
     case "placesCmd_createBookmark":
       let node = this._view.selectedNode;
       PlacesUIUtils.showBookmarkDialog({ action: "add",
                                          type: "bookmark",
                                          hiddenRows: [ "description",
                                                         "keyword",
                                                         "location",

--- a/browser/components/places/content/menu.xml
+++ b/browser/components/places/content/menu.xml
@@ -358,17 +358,17 @@
       ]]></handler>
 
       <handler event="drop"><![CDATA[
         PlacesControllerDragHelper.currentDropTarget = event.target;
 
         let dropPoint = this._getDropPoint(event);
         if (dropPoint && dropPoint.ip) {
           PlacesControllerDragHelper.onDrop(dropPoint.ip, event.dataTransfer)
-                                    .then(null, Components.utils.reportError);
+                                    .catch(Components.utils.reportError);
           event.preventDefault();
         }
 
         this._cleanupDragDetails();
         event.stopPropagation();
       ]]></handler>
 
       <handler event="dragover"><![CDATA[

--- a/browser/components/places/content/moveBookmarks.js
+++ b/browser/components/places/content/moveBookmarks.js
@@ -49,17 +49,17 @@ var gMoveBookmarksDialog = {
       let newParentGuid = await PlacesUtils.promiseItemGuid(selectedFolderId);
       for (let node of this._nodes) {
         // Nothing to do if the node is already under the selected folder.
         if (node.parent.itemId == selectedFolderId)
           continue;
         await PlacesTransactions.Move({ guid: node.bookmarkGuid,
                                         newParentGuid }).transact();
       }
-    }).then(null, Components.utils.reportError);
+    }).catch(Components.utils.reportError);
   },
 
   newFolder: function MBD_newFolder() {
     // The command is disabled when the tree is not focused
     this.foldersTree.focus();
     goDoCommand("placesCmd_new:folder");
   }
 };

--- a/browser/components/places/content/places.js
+++ b/browser/components/places/content/places.js
@@ -369,17 +369,17 @@ var PlacesOrganizer = {
    * Open a file-picker and import the selected file into the bookmarks store
    */
   importFromFile: function PO_importFromFile() {
     let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
     let fpCallback = function fpCallback_done(aResult) {
       if (aResult != Ci.nsIFilePicker.returnCancel && fp.fileURL) {
         Components.utils.import("resource://gre/modules/BookmarkHTMLUtils.jsm");
         BookmarkHTMLUtils.importFromURL(fp.fileURL.spec, false)
-                         .then(null, Components.utils.reportError);
+                         .catch(Components.utils.reportError);
       }
     };
 
     fp.init(window, PlacesUIUtils.getString("SelectImport"),
             Ci.nsIFilePicker.modeOpen);
     fp.appendFilters(Ci.nsIFilePicker.filterHTML);
     fp.open(fpCallback);
   },
@@ -388,17 +388,17 @@ var PlacesOrganizer = {
    * Allows simple exporting of bookmarks.
    */
   exportBookmarks: function PO_exportBookmarks() {
     let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
     let fpCallback = function fpCallback_done(aResult) {
       if (aResult != Ci.nsIFilePicker.returnCancel) {
         Components.utils.import("resource://gre/modules/BookmarkHTMLUtils.jsm");
         BookmarkHTMLUtils.exportToFile(fp.file.path)
-                         .then(null, Components.utils.reportError);
+                         .catch(Components.utils.reportError);
       }
     };
 
     fp.init(window, PlacesUIUtils.getString("EnterExport"),
             Ci.nsIFilePicker.modeSave);
     fp.appendFilters(Ci.nsIFilePicker.filterHTML);
     fp.defaultString = "bookmarks.html";
     fp.open(fpCallback);

--- a/browser/components/places/content/treeView.js
+++ b/browser/components/places/content/treeView.js
@@ -1352,17 +1352,17 @@ PlacesTreeView.prototype = {
 
   drop: function PTV_drop(aRow, aOrientation, aDataTransfer) {
     // We are responsible for translating the |index| and |orientation|
     // parameters into a container id and index within the container,
     // since this information is specific to the tree view.
     let ip = this._getInsertionPoint(aRow, aOrientation);
     if (ip) {
       PlacesControllerDragHelper.onDrop(ip, aDataTransfer)
-                                .then(null, Components.utils.reportError);
+                                .catch(Components.utils.reportError);
     }
 
     PlacesControllerDragHelper.currentDropTarget = null;
   },
 
   getParentIndex: function PTV_getParentIndex(aRow) {
     let [, parentRow] = this._getParentByChildRow(aRow);
     return parentRow;

--- a/browser/components/privatebrowsing/test/browser/browser_privatebrowsing_downloadLastDir_c.js
+++ b/browser/components/privatebrowsing/test/browser/browser_privatebrowsing_downloadLastDir_c.js
@@ -73,17 +73,17 @@ function test() {
          "LastDir should be the expected last dir");
       // gDownloadLastDir should be usable outside of private windows
       is(gDownloadLastDir.file.path, aGlobalLastDir.path,
          "gDownloadLastDir should be the expected global last dir");
 
       gDownloadLastDir.cleanupPrivateFile();
       aWin.close();
       aCallback();
-    }).then(null, function() { ok(false); });
+    }).catch(function() { ok(false); });
   }
 
   testOnWindow(false, function(win, downloadDir) {
     testDownloadDir(win, downloadDir, file1, tmpDir, dir1, dir1, function() {
       testOnWindow(true, function(win1, downloadDir1) {
         testDownloadDir(win1, downloadDir1, file2, dir1, dir1, dir2, function() {
           testOnWindow(false, function(win2, downloadDir2) {
             testDownloadDir(win2, downloadDir2, file3, dir1, dir3, dir3, finish);

--- a/browser/components/tests/startupRecorder.js
+++ b/browser/components/tests/startupRecorder.js
@@ -63,19 +63,20 @@ startupRecorder.prototype = {
       for (let t of topics)
         Services.obs.addObserver(this, t);
       return;
     }
 
     Services.obs.removeObserver(this, topic);
 
     if (topic == "sessionstore-windows-restored") {
-      // We use idleDispatch here to record the set of loaded scripts after we
-      // are fully done with startup and ready to react to user events.
-      Services.tm.mainThread.idleDispatch(
+      // We use idleDispatchToMainThread here to record the set of
+      // loaded scripts after we are fully done with startup and ready
+      // to react to user events.
+      Services.tm.idleDispatchToMainThread(
         this.record.bind(this, "before handling user events"));
     } else {
       const topicsToNames = {
         "profile-do-change": "before profile selection",
         "toplevel-window-ready": "before opening first browser window",
       };
       topicsToNames[firstPaintNotification] = "before first paint";
       this.record(topicsToNames[topic]);

--- a/browser/components/uitour/UITour.jsm
+++ b/browser/components/uitour/UITour.jsm
@@ -648,17 +648,17 @@ this.UITour = {
             let onPopupShown = () => {
               searchbar.textbox.popup.removeEventListener("popupshown", onPopupShown);
               this.sendPageCallback(messageManager, data.callbackID);
             };
 
             searchbar.textbox.popup.addEventListener("popupshown", onPopupShown);
             searchbar.openSuggestionsPanel();
           }
-        }).then(null, Cu.reportError);
+        }).catch(Cu.reportError);
         break;
       }
 
       case "ping": {
         if (typeof data.callbackID == "string")
           this.sendPageCallback(messageManager, data.callbackID);
         break;
       }

--- a/browser/components/uitour/test/browser_UITour.js
+++ b/browser/components/uitour/test/browser_UITour.js
@@ -154,17 +154,17 @@ var tests = [
         gContentAPI.showHighlight("appMenu");
         waitForElementToBeVisible(highlight, function() {
           isnot(PanelUI.panel.state, "closed",
                 "Panel should remain open since UITour didn't open it in the first place");
           gContentAPI.hideMenu("appMenu");
           done();
         }, "Highlight should move to the appMenu button");
       }, "Highlight should be shown after showHighlight() for fixed panel items");
-    }).then(null, Components.utils.reportError);
+    }).catch(Components.utils.reportError);
   },
   function test_highlight_effect(done) {
     function waitForHighlightWithEffect(highlightEl, effect, next, error) {
       return waitForCondition(() => highlightEl.getAttribute("active") == effect,
                               next,
                               error);
     }
     function checkDefaultEffect() {

--- a/browser/components/uitour/test/browser_UITour2.js
+++ b/browser/components/uitour/test/browser_UITour2.js
@@ -58,17 +58,17 @@ var tests = [
                 ok(!PanelUI.panel.hasAttribute("noautohide"), "@noautohide on the menu panel should have been cleaned up on close");
                 done();
               });
               gContentAPI.hideMenu("appMenu");
             }, "Info should move to the appMenu button");
           });
         }, "Info should be shown after showInfo() for fixed menu panel items");
       });
-    }).then(null, Components.utils.reportError);
+    }).catch(Components.utils.reportError);
   },
   taskify(async function test_bookmarks_menu() {
     let bookmarksMenuButton = document.getElementById("bookmarks-menu-button");
 
     is(bookmarksMenuButton.open, false, "Menu should initially be closed");
     gContentAPI.showMenu("bookmarks");
 
     await waitForConditionPromise(() => {

--- a/browser/experiments/test/addons/experiment-racybranch/bootstrap.js
+++ b/browser/experiments/test/addons/experiment-racybranch/bootstrap.js
@@ -21,14 +21,14 @@ function realstartup() {
   let experiment = experiments._getActiveExperiment();
   if (experiment.branch) {
     Cu.reportError("Found pre-existing branch: " + experiment.branch);
     return;
   }
 
   let branch = "racy-set";
   experiments.setExperimentBranch(experiment.id, branch)
-    .then(null, Cu.reportError);
+    .catch(Cu.reportError);
 }
 
 function shutdown() { }
 function install() { }
 function uninstall() { }

--- a/browser/modules/AboutHome.jsm
+++ b/browser/modules/AboutHome.jsm
@@ -182,14 +182,14 @@ var AboutHome = {
       }
 
       if (target && target.messageManager) {
         target.messageManager.sendAsyncMessage("AboutHome:Update", data);
       } else {
         let mm = Cc["@mozilla.org/globalmessagemanager;1"].getService(Ci.nsIMessageListenerManager);
         mm.broadcastAsyncMessage("AboutHome:Update", data);
       }
-    }).then(null, function onError(x) {
+    }).catch(function onError(x) {
       Cu.reportError("Error in AboutHome.sendAboutHomeData: " + x);
     });
   },
 
 };

--- a/browser/themes/linux/browser.css
+++ b/browser/themes/linux/browser.css
@@ -688,43 +688,47 @@ html|span.ac-tag {
 
 html|span.ac-emphasize-text-title,
 html|span.ac-emphasize-text-tag,
 html|span.ac-emphasize-text-url {
   font-weight: 600;
 }
 
 .ac-type-icon[type=bookmark] {
-  list-style-image: url("chrome://browser/skin/urlbar-star.svg#star");
+  list-style-image: url("chrome://browser/skin/bookmark.svg");
+  -moz-context-properties: fill;
+  fill: #b2b2b2;
 }
 
 .ac-type-icon[type=bookmark][selected][current] {
-  list-style-image: url("chrome://browser/skin/urlbar-star.svg#star-inverted");
+  fill: white;
 }
 
 .ac-type-icon[type=keyword],
 .ac-site-icon[type=searchengine] {
   list-style-image: url(chrome://global/skin/icons/autocomplete-search.svg);
   -moz-context-properties: fill;
   fill: GrayText;
 }
 
 .ac-type-icon[type=keyword][selected],
 .ac-site-icon[type=searchengine][selected] {
   fill: highlighttext;
 }
 
 .ac-type-icon[type=switchtab],
 .ac-type-icon[type=remotetab] {
-  list-style-image: url("chrome://browser/skin/urlbar-tab.svg#tab");
+  list-style-image: url("chrome://browser/skin/urlbar-tab.svg");
+  -moz-context-properties: fill;
+  fill: #b2b2b2;
 }
 
 .ac-type-icon[type=switchtab][selected],
 .ac-type-icon[type=remotetab][selected] {
-  list-style-image: url("chrome://browser/skin/urlbar-tab.svg#tab-inverted");
+  fill: white;
 }
 
 .autocomplete-treebody::-moz-tree-cell-text(treecolAutoCompleteComment) {
   color: GrayText;
 }
 
 .autocomplete-treebody::-moz-tree-cell-text(suggesthint, treecolAutoCompleteComment),
 .autocomplete-treebody::-moz-tree-cell-text(suggestfirst, treecolAutoCompleteComment) {

--- a/browser/themes/osx/browser.css
+++ b/browser/themes/osx/browser.css
@@ -846,43 +846,47 @@ html|span.ac-tag {
 
 html|span.ac-emphasize-text-title,
 html|span.ac-emphasize-text-tag,
 html|span.ac-emphasize-text-url {
   font-weight: 600;
 }
 
 .ac-type-icon[type=bookmark] {
-  list-style-image: url("chrome://browser/skin/urlbar-star.svg#star");
+  list-style-image: url("chrome://browser/skin/bookmark.svg");
+  -moz-context-properties: fill;
+  fill: #b2b2b2;
 }
 
 .ac-type-icon[type=bookmark][selected][current] {
-  list-style-image: url("chrome://browser/skin/urlbar-star.svg#star-inverted");
+  fill: white;
 }
 
 .ac-type-icon[type=keyword],
 .ac-site-icon[type=searchengine] {
   list-style-image: url(chrome://global/skin/icons/autocomplete-search.svg);
   -moz-context-properties: fill;
   fill: GrayText;
 }
 
 .ac-type-icon[type=keyword][selected],
 .ac-site-icon[type=searchengine][selected] {
   fill: highlighttext;
 }
 
 .ac-type-icon[type=switchtab],
 .ac-type-icon[type=remotetab] {
-  list-style-image: url("chrome://browser/skin/urlbar-tab.svg#tab");
+  list-style-image: url("chrome://browser/skin/urlbar-tab.svg");
+  -moz-context-properties: fill;
+  fill: #b2b2b2;
 }
 
 .ac-type-icon[type=switchtab][selected],
 .ac-type-icon[type=remotetab][selected] {
-  list-style-image: url("chrome://browser/skin/urlbar-tab.svg#tab-inverted");
+  fill: white;
 }
 
 .autocomplete-treebody::-moz-tree-cell-text(treecolAutoCompleteComment) {
   color: GrayText;
 }
 
 .autocomplete-treebody::-moz-tree-cell-text(suggesthint, treecolAutoCompleteComment),
 .autocomplete-treebody::-moz-tree-cell-text(suggestfirst, treecolAutoCompleteComment)

--- a/browser/themes/shared/jar.inc.mn
+++ b/browser/themes/shared/jar.inc.mn
@@ -213,10 +213,9 @@
   skin/classic/browser/privatebrowsing/aboutPrivateBrowsing.css (../shared/privatebrowsing/aboutPrivateBrowsing.css)
   skin/classic/browser/privatebrowsing/favicon.svg             (../shared/privatebrowsing/favicon.svg)
   skin/classic/browser/privatebrowsing/private-browsing.svg    (../shared/privatebrowsing/private-browsing.svg)
   skin/classic/browser/privatebrowsing/tracking-protection-off.svg (../shared/privatebrowsing/tracking-protection-off.svg)
   skin/classic/browser/privatebrowsing/tracking-protection.svg (../shared/privatebrowsing/tracking-protection.svg)
   skin/classic/browser/compacttheme/loading-inverted.png (../shared/compacttheme/loading-inverted.png)
   skin/classic/browser/compacttheme/loading-inverted@2x.png (../shared/compacttheme/loading-inverted@2x.png)
   skin/classic/browser/compacttheme/urlbar-history-dropmarker.svg (../shared/compacttheme/urlbar-history-dropmarker.svg)
-  skin/classic/browser/urlbar-star.svg                         (../shared/urlbar-star.svg)
   skin/classic/browser/urlbar-tab.svg                          (../shared/urlbar-tab.svg)

--- a/browser/themes/shared/sync-desktopIcon.svg
+++ b/browser/themes/shared/sync-desktopIcon.svg
@@ -1,22 +1,8 @@
 <!-- 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/. -->
-<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
-  <style>
-    g:not(:target) { display: none; }
-
-    .glyph { fill: #4d4d4d; }
-    .glyph.translucent { fill-opacity: .15; }
-
-    .inverted .glyph { fill: #fff; }
-    .inverted .glyph.translucent { fill-opacity: .15; }
-  </style>
-  <g id="icon">
-    <path class="glyph" d="M15,14H1a1,1,0,0,1-1-1V12.526H16V13A1,1,0,0,1,15,14ZM1,4A1,1,0,0,1,2,3H14a1,1,0,0,1,1,1v8H1V4Zm1,7H14V4H2v7Z"/>
-    <rect class="glyph translucent" x="2" y="4" width="12" height="7"/>
-  </g>
-  <g id="icon-inverted" class="inverted">
-    <path class="glyph" d="M15,14H1a1,1,0,0,1-1-1V12.526H16V13A1,1,0,0,1,15,14ZM1,4A1,1,0,0,1,2,3H14a1,1,0,0,1,1,1v8H1V4Zm1,7H14V4H2v7Z"/>
-    <rect class="glyph translucent" x="2" y="4" width="12" height="7"/>
-  </g>
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="16" height="16" viewBox="0 0 16 16">
+  <path fill="context-fill" d="M15,14H1a1,1,0,0,1-1-1V12.526H16V13A1,1,0,0,1,15,14ZM1,4A1,1,0,0,1,2,3H14a1,1,0,0,1,1,1v8H1V4Zm1,7H14V4H2v7Z"/>
+  <rect fill="context-fill" fill-opacity="0.15" x="2" y="4" width="12" height="7"/>
 </svg>

--- a/browser/themes/shared/sync-mobileIcon.svg
+++ b/browser/themes/shared/sync-mobileIcon.svg
@@ -1,22 +1,8 @@
 <!-- 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/. -->
-<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
-  <style>
-    g:not(:target) { display: none; }
-
-    .glyph { fill: #4d4d4d; }
-    .glyph.translucent { fill-opacity: .15; }
-
-    .inverted .glyph { fill: #fff; }
-    .inverted .glyph.translucent { fill-opacity: .15; }
-  </style>
-  <g id="icon">
-    <path class="glyph" d="M12,16H4a1,1,0,0,1-1-1V1A1,1,0,0,1,4,0h8a1,1,0,0,1,1,1V15A1,1,0,0,1,12,16Zm-4-.684a0.785,0.785,0,1,0-.785-0.785A0.785,0.785,0,0,0,8,15.316ZM12,2H4V13h8V2Z"/>
-    <rect class="glyph translucent" x="4" y="2" width="8" height="11"/>
-  </g>
-  <g id="icon-inverted" class="inverted">
-    <path class="glyph" d="M12,16H4a1,1,0,0,1-1-1V1A1,1,0,0,1,4,0h8a1,1,0,0,1,1,1V15A1,1,0,0,1,12,16Zm-4-.684a0.785,0.785,0,1,0-.785-0.785A0.785,0.785,0,0,0,8,15.316ZM12,2H4V13h8V2Z"/>
-    <rect class="glyph translucent" x="4" y="2" width="8" height="11"/>
-  </g>
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="16" height="16" viewBox="0 0 16 16">
+  <path fill="context-fill" d="M12,16H4a1,1,0,0,1-1-1V1A1,1,0,0,1,4,0h8a1,1,0,0,1,1,1V15A1,1,0,0,1,12,16Zm-4-.684a0.785,0.785,0,1,0-.785-0.785A0.785,0.785,0,0,0,8,15.316ZM12,2H4V13h8V2Z"/>
+  <rect fill="context-fill" fill-opacity="0.15" x="4" y="2" width="8" height="11"/>
 </svg>

--- a/browser/themes/shared/syncedtabs/sidebar.inc.css
+++ b/browser/themes/shared/syncedtabs/sidebar.inc.css
@@ -85,29 +85,33 @@ body {
   padding-inline-start: 35px;
 }
 
 .item.tab > .item-title-container {
   padding-inline-start: 20px;
 }
 
 .item.client.device-image-desktop > .item-title-container > .item-icon-container {
-  background-image: url("chrome://browser/skin/sync-desktopIcon.svg#icon");
+  background-image: url("chrome://browser/skin/sync-desktopIcon.svg");
+  -moz-context-properties: fill;
+  fill: #4d4d4d;
 }
 
 .item.client.device-image-desktop.selected:focus > .item-title-container > .item-icon-container {
-  background-image: url("chrome://browser/skin/sync-desktopIcon.svg#icon-inverted");
+  fill: white;
 }
 
 .item.client.device-image-mobile > .item-title-container > .item-icon-container {
-  background-image: url("chrome://browser/skin/sync-mobileIcon.svg#icon");
+  background-image: url("chrome://browser/skin/sync-mobileIcon.svg");
+  -moz-context-properties: fill;
+  fill: #4d4d4d;
 }
 
 .item.client.device-image-mobile.selected:focus > .item-title-container > .item-icon-container {
-  background-image: url("chrome://browser/skin/sync-mobileIcon.svg#icon-inverted");
+  fill: white;
 }
 
 .item.tab > .item-title-container > .item-icon-container {
   background-image: url("chrome://mozapps/skin/places/defaultFavicon.svg");
 }
 
 .item-icon-container {
   min-width: 16px;

deleted file mode 100644
--- a/browser/themes/shared/urlbar-star.svg
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.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/. -->
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="16" height="16" viewBox="0 0 16 16">
-  <style>
-    path:not(:target) {
-      display: none;
-    }
-    path {
-      fill: #b2b2b2;
-    }
-    path[id$="-inverted"] {
-      fill: #fff;
-    }
-  </style>
-
-	<path id="star" d="M8.7,0.5l2,4.3l4.6,0.7c0.6,0.1,0.9,0.9,0.4,1.4l-3.3,3.4l0.8,4.8c0.1,0.7-0.6,1.2-1.1,0.9L8,13.7l-4.1,2.3 c-0.6,0.3-1.2-0.2-1.1-0.9l0.8-4.8L0.2,6.9C-0.2,6.4,0,5.6,0.7,5.5l4.6-0.7l2-4.3C7.6-0.1,8.4-0.1,8.7,0.5z"/>
-	<path id="star-inverted" d="M8.7,0.5l2,4.3l4.6,0.7c0.6,0.1,0.9,0.9,0.4,1.4l-3.3,3.4l0.8,4.8c0.1,0.7-0.6,1.2-1.1,0.9L8,13.7l-4.1,2.3 c-0.6,0.3-1.2-0.2-1.1-0.9l0.8-4.8L0.2,6.9C-0.2,6.4,0,5.6,0.7,5.5l4.6-0.7l2-4.3C7.6-0.1,8.4-0.1,8.7,0.5z"/>
-</svg>

--- a/browser/themes/shared/urlbar-tab.svg
+++ b/browser/themes/shared/urlbar-tab.svg
@@ -1,21 +1,7 @@
-<?xml version="1.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/. -->
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="16" height="16" viewBox="0 0 16 16">
-  <style>
-    path:not(:target) {
-      display: none;
-    }
-    path {
-      fill: #b2b2b2;
-    }
-    path[id$="-inverted"] {
-      fill: #fff;
-    }
-  </style>
-
-  <path id="tab" d="M14,9.5V6c0-1.7-1.3-3-3-3H5C3.3,3,2,4.3,2,6v3.5C2,10.3,1.3,11,0.5,11h0C0.2,11,0,11.2,0,11.5v1 C0,12.8,0.2,13,0.5,13h15c0.3,0,0.5-0.2,0.5-0.5v-1c0-0.3-0.2-0.5-0.5-0.5h0C14.7,11,14,10.3,14,9.5z"/>
-  <path id="tab-inverted" d="M14,9.5V6c0-1.7-1.3-3-3-3H5C3.3,3,2,4.3,2,6v3.5C2,10.3,1.3,11,0.5,11h0C0.2,11,0,11.2,0,11.5v1 C0,12.8,0.2,13,0.5,13h15c0.3,0,0.5-0.2,0.5-0.5v-1c0-0.3-0.2-0.5-0.5-0.5h0C14.7,11,14,10.3,14,9.5z"/>
-
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="16" height="16" viewBox="0 0 16 16">
+  <path fill="context-fill" d="M14,9.5V6c0-1.7-1.3-3-3-3H5C3.3,3,2,4.3,2,6v3.5C2,10.3,1.3,11,0.5,11h0C0.2,11,0,11.2,0,11.5v1 C0,12.8,0.2,13,0.5,13h15c0.3,0,0.5-0.2,0.5-0.5v-1c0-0.3-0.2-0.5-0.5-0.5h0C14.7,11,14,10.3,14,9.5z"/>
 </svg>

--- a/browser/themes/windows/browser.css
+++ b/browser/themes/windows/browser.css
@@ -1072,43 +1072,47 @@ treechildren.searchbar-treebody::-moz-tr
 
 .autocomplete-richlistitem[selected],
 treechildren.searchbar-treebody::-moz-tree-row(selected) {
   background-color: Highlight;
   color: HighlightText;
 }
 
 .ac-type-icon[type=bookmark] {
-  list-style-image: url("chrome://browser/skin/urlbar-star.svg#star");
+  list-style-image: url("chrome://browser/skin/bookmark.svg");
+  -moz-context-properties: fill;
+  fill: #b2b2b2;
 }
 
 .ac-type-icon[type=bookmark][selected][current] {
-  list-style-image: url("chrome://browser/skin/urlbar-star.svg#star-inverted");
+  fill: white;
 }
 
 .ac-type-icon[type=keyword],
 .ac-site-icon[type=searchengine] {
   list-style-image: url(chrome://global/skin/icons/autocomplete-search.svg);
   -moz-context-properties: fill;
   fill: GrayText;
 }
 
 .ac-type-icon[type=keyword][selected],
 .ac-site-icon[type=searchengine][selected] {
   fill: highlighttext;
 }
 
 .ac-type-icon[type=switchtab],
 .ac-type-icon[type=remotetab] {
-  list-style-image: url("chrome://browser/skin/urlbar-tab.svg#tab");
+  list-style-image: url("chrome://browser/skin/urlbar-tab.svg");
+  -moz-context-properties: fill;
+  fill: #b2b2b2;
 }
 
 .ac-type-icon[type=switchtab][selected],
 .ac-type-icon[type=remotetab][selected] {
-  list-style-image: url("chrome://browser/skin/urlbar-tab.svg#tab-inverted");
+  fill: white;
 }
 
 .autocomplete-treebody::-moz-tree-cell-text(treecolAutoCompleteComment) {
   color: GrayText;
 }
 
 .autocomplete-treebody::-moz-tree-cell-text(suggesthint, treecolAutoCompleteComment),
 .autocomplete-treebody::-moz-tree-cell-text(suggestfirst, treecolAutoCompleteComment)