Merge inbound to mozilla-central. a=merge
authorBogdan Tara <btara@mozilla.com>
Wed, 01 Aug 2018 00:58:55 +0300
changeset 484568 d57a89840dbb
parent 484495 929ceb6c82fa (current diff)
parent 484567 01d7fd373ccb (diff)
child 484584 d99af6383af1
child 484632 28fe368934e8
push id9719
push userffxbld-merge
push dateFri, 24 Aug 2018 17:49:46 +0000
treeherdermozilla-beta@719ec98fba77 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone63.0a1
first release with
nightly linux32
d57a89840dbb / 63.0a1 / 20180731220208 / files
nightly linux64
d57a89840dbb / 63.0a1 / 20180731220208 / files
nightly mac
d57a89840dbb / 63.0a1 / 20180731220208 / files
nightly win32
d57a89840dbb / 63.0a1 / 20180731220208 / files
nightly win64
d57a89840dbb / 63.0a1 / 20180731220208 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge inbound to mozilla-central. a=merge
browser/components/extensions/test/browser/browser_ext_user_events.js
js/src/jit/arm/SharedIC-arm.cpp
js/src/jit/arm64/SharedIC-arm64.cpp
js/src/jit/mips32/SharedIC-mips32.cpp
js/src/jit/mips64/SharedIC-mips64.cpp
js/src/jit/x64/SharedIC-x64.cpp
js/src/jit/x86/SharedIC-x86.cpp
testing/mochitest/bootstrap.js
testing/mochitest/jar.mn
testing/web-platform/meta/clipboard-apis/async-navigator-clipboard-basics.https.html.ini
testing/web-platform/meta/picture-in-picture/request-picture-in-picture-twice.html.ini
testing/web-platform/tests/html/rendering/non-replaced-elements/tables/form-in-tables.xhtml
testing/web-platform/tests/pointerevents/idlharness.html
testing/web-platform/tests/svg/interfaces.html
testing/web-platform/tests/tools/ci/taskgraph.py
widget/android/ScreenHelperAndroid.cpp
widget/android/ScreenHelperAndroid.h
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -4304,16 +4304,28 @@ nsDocShell::DisplayLoadError(nsresult aE
   bool addHostPort = false;
   nsresult rv = NS_OK;
   nsAutoString messageStr;
   nsAutoCString cssClass;
   nsAutoCString errorPage;
 
   errorPage.AssignLiteral("neterror");
 
+  if (mLoadURIDelegate) {
+    bool loadErrorHandled = false;
+    rv = mLoadURIDelegate->HandleLoadError(aURI, aError,
+                                           NS_ERROR_GET_MODULE(aError),
+                                           &loadErrorHandled);
+    if (NS_SUCCEEDED(rv) && loadErrorHandled) {
+      // The request has been handled, nothing to do here.
+      *aDisplayedErrorPage = false;
+      return NS_OK;
+    }
+  }
+
   // Turn the error code into a human readable error message.
   if (NS_ERROR_UNKNOWN_PROTOCOL == aError) {
     NS_ENSURE_ARG_POINTER(aURI);
 
     // Extract the schemes into a comma delimited list.
     nsAutoCString scheme;
     aURI->GetScheme(scheme);
     CopyASCIItoUTF16(scheme, formatStrs[0]);
--- a/dom/base/FormData.cpp
+++ b/dom/base/FormData.cpp
@@ -12,17 +12,17 @@
 #include "mozilla/Encoding.h"
 
 #include "MultipartBlobImpl.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
 FormData::FormData(nsISupports* aOwner)
-  : HTMLFormSubmission(UTF_8_ENCODING, nullptr)
+  : HTMLFormSubmission(nullptr, EmptyString(), UTF_8_ENCODING, nullptr)
   , mOwner(aOwner)
 {
 }
 
 namespace {
 
 already_AddRefed<File>
 GetOrCreateFileCalledBlob(Blob& aBlob, ErrorResult& aRv)
@@ -345,17 +345,17 @@ FormData::Constructor(const GlobalObject
 
 // contentTypeWithCharset can be set to the contentType or
 // contentType+charset based on what the spec says.
 // See: https://fetch.spec.whatwg.org/#concept-bodyinit-extract
 nsresult
 FormData::GetSendInfo(nsIInputStream** aBody, uint64_t* aContentLength,
                       nsACString& aContentTypeWithCharset, nsACString& aCharset) const
 {
-  FSMultipartFormData fs(UTF_8_ENCODING, nullptr);
+  FSMultipartFormData fs(nullptr, EmptyString(), UTF_8_ENCODING, nullptr);
 
   for (uint32_t i = 0; i < mFormData.Length(); ++i) {
     if (mFormData[i].wasNullBlob) {
       MOZ_ASSERT(mFormData[i].value.IsUSVString());
       fs.AddNameBlobOrNullPair(mFormData[i].name, nullptr);
     } else if (mFormData[i].value.IsUSVString()) {
       fs.AddNameValuePair(mFormData[i].name,
                           mFormData[i].value.GetAsUSVString());
--- a/dom/base/Navigator.cpp
+++ b/dom/base/Navigator.cpp
@@ -29,16 +29,17 @@
 #include "nsCharSeparatedTokenizer.h"
 #include "nsContentUtils.h"
 #include "nsUnicharUtils.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/StaticPrefs.h"
 #include "mozilla/Telemetry.h"
 #include "BatteryManager.h"
 #include "mozilla/dom/CredentialsContainer.h"
+#include "mozilla/dom/Clipboard.h"
 #include "mozilla/dom/GamepadServiceTest.h"
 #include "mozilla/dom/MediaCapabilities.h"
 #include "mozilla/dom/WakeLock.h"
 #include "mozilla/dom/power/PowerManagerService.h"
 #include "mozilla/dom/MIDIAccessManager.h"
 #include "mozilla/dom/MIDIOptionsBinding.h"
 #include "mozilla/dom/Permissions.h"
 #include "mozilla/dom/Presentation.h"
@@ -1770,16 +1771,25 @@ Navigator::MediaCapabilities()
 {
   if (!mMediaCapabilities) {
     mMediaCapabilities =
       new dom::MediaCapabilities(GetWindow()->AsGlobal());
   }
   return mMediaCapabilities;
 }
 
+Clipboard*
+Navigator::Clipboard()
+{
+  if (!mClipboard) {
+    mClipboard = new dom::Clipboard(GetWindow());
+  }
+  return mClipboard;
+}
+
 /* static */
 bool
 Navigator::Webdriver()
 {
   return Preferences::GetBool("marionette.enabled", false);
 }
 
 } // namespace dom
--- a/dom/base/Navigator.h
+++ b/dom/base/Navigator.h
@@ -35,16 +35,17 @@ class Geolocation;
 class systemMessageCallback;
 class MediaDevices;
 struct MediaStreamConstraints;
 class WakeLock;
 class ArrayBufferOrArrayBufferViewOrBlobOrFormDataOrUSVStringOrURLSearchParams;
 class ServiceWorkerContainer;
 class DOMRequest;
 class CredentialsContainer;
+class Clipboard;
 } // namespace dom
 } // namespace mozilla
 
 //*****************************************************************************
 // Navigator: Script "navigator" object
 //*****************************************************************************
 
 namespace mozilla {
@@ -202,16 +203,17 @@ public:
                               NavigatorUserMediaErrorCallback& aOnError,
                               uint64_t aInnerWindowID,
                               const nsAString& aCallID,
                               ErrorResult& aRv);
 
   already_AddRefed<ServiceWorkerContainer> ServiceWorker();
 
   mozilla::dom::CredentialsContainer* Credentials();
+  dom::Clipboard* Clipboard();
 
   static bool Webdriver();
 
   void GetLanguages(nsTArray<nsString>& aLanguages);
 
   StorageManager* Storage();
 
   static void GetAcceptLanguages(nsTArray<nsString>& aLanguages);
@@ -263,16 +265,17 @@ private:
   RefPtr<nsMimeTypeArray> mMimeTypes;
   RefPtr<nsPluginArray> mPlugins;
   RefPtr<Permissions> mPermissions;
   RefPtr<Geolocation> mGeolocation;
   RefPtr<battery::BatteryManager> mBatteryManager;
   RefPtr<Promise> mBatteryPromise;
   RefPtr<network::Connection> mConnection;
   RefPtr<CredentialsContainer> mCredentials;
+  RefPtr<dom::Clipboard> mClipboard;
   RefPtr<MediaDevices> mMediaDevices;
   RefPtr<ServiceWorkerContainer> mServiceWorkerContainer;
   nsCOMPtr<nsPIDOMWindowInner> mWindow;
   RefPtr<Presentation> mPresentation;
   RefPtr<GamepadServiceTest> mGamepadServiceTest;
   nsTArray<RefPtr<Promise> > mVRGetDisplaysPromises;
   RefPtr<VRServiceTest> mVRServiceTest;
   nsTArray<uint32_t> mRequestedVibrationPattern;
--- a/dom/bindings/Bindings.conf
+++ b/dom/bindings/Bindings.conf
@@ -138,16 +138,20 @@ DOMInterfaces = {
 'ChannelWrapper': {
     'nativeType': 'mozilla::extensions::ChannelWrapper',
 },
 
 'CharacterData': {
     'concrete': False
 },
 
+'Clipboard' : {
+    'implicitJSContext' : ['write', 'writeText', 'read', 'readText'],
+},
+
 'console': {
     'nativeType': 'mozilla::dom::Console',
 },
 
 'ConsoleInstance': {
     'implicitJSContext': ['clear', 'count', 'countReset', 'groupEnd', 'time', 'timeEnd'],
 },
 
new file mode 100644
--- /dev/null
+++ b/dom/events/Clipboard.cpp
@@ -0,0 +1,220 @@
+/* -*- 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 "mozilla/AbstractThread.h"
+#include "mozilla/dom/Clipboard.h"
+#include "mozilla/dom/ClipboardBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/DataTransfer.h"
+#include "mozilla/dom/DataTransferItemList.h"
+#include "mozilla/dom/DataTransferItem.h"
+#include "mozilla/dom/ContentChild.h"
+#include "nsIClipboard.h"
+#include "nsISupportsPrimitives.h"
+#include "nsComponentManagerUtils.h"
+#include "nsITransferable.h"
+#include "nsArrayUtils.h"
+
+
+static mozilla::LazyLogModule gClipboardLog("Clipboard");
+
+namespace mozilla {
+namespace dom {
+
+Clipboard::Clipboard(nsPIDOMWindowInner* aWindow)
+: DOMEventTargetHelper(aWindow)
+{
+}
+
+Clipboard::~Clipboard()
+{
+}
+
+already_AddRefed<Promise>
+Clipboard::ReadHelper(JSContext* aCx, nsIPrincipal& aSubjectPrincipal,
+                      ClipboardReadType aClipboardReadType, ErrorResult& aRv)
+{
+  // Create a new promise
+  RefPtr<Promise> p = dom::Promise::Create(GetOwnerGlobal(), aRv);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+
+  // We want to disable security check for automated tests that have the pref
+  //  dom.events.testing.asyncClipboard set to true
+  if (!IsTestingPrefEnabled() && !nsContentUtils::PrincipalHasPermission(&aSubjectPrincipal,
+                                                         nsGkAtoms::clipboardRead)) {
+    MOZ_LOG(GetClipboardLog(), LogLevel::Debug, ("Clipboard, ReadHelper, "
+            "Don't have permissions for reading\n"));
+    p->MaybeRejectWithUndefined();
+    return p.forget();
+  }
+
+  // Want isExternal = true in order to use the data transfer object to perform a read
+  RefPtr<DataTransfer> dataTransfer = new DataTransfer(this, ePaste, /* is external */ true,
+                                                       nsIClipboard::kGlobalClipboard);
+
+  // Create a new runnable
+  RefPtr<nsIRunnable> r = NS_NewRunnableFunction(
+    "Clipboard::Read",
+    [p, dataTransfer, &aSubjectPrincipal, aClipboardReadType]() {
+      IgnoredErrorResult ier;
+      switch (aClipboardReadType) {
+        case eRead:
+          MOZ_LOG(GetClipboardLog(), LogLevel::Debug,
+                  ("Clipboard, ReadHelper, read case\n"));
+          dataTransfer->FillAllExternalData();
+          // If there are items on the clipboard, data transfer will contain those,
+          // else, data transfer will be empty and we will be resolving with an empty data transfer
+          p->MaybeResolve(dataTransfer);
+          break;
+        case eReadText:
+          MOZ_LOG(GetClipboardLog(), LogLevel::Debug,
+                  ("Clipboard, ReadHelper, read text case\n"));
+          nsAutoString str;
+          dataTransfer->GetData(NS_LITERAL_STRING(kTextMime), str, aSubjectPrincipal, ier);
+          // Either resolve with a string extracted from data transfer item
+          // or resolve with an empty string if nothing was found
+          p->MaybeResolve(str);
+          break;
+      }
+    });
+  // Dispatch the runnable
+  GetParentObject()->Dispatch(TaskCategory::Other, r.forget());
+  return p.forget();
+}
+
+already_AddRefed<Promise>
+Clipboard::Read(JSContext* aCx, nsIPrincipal& aSubjectPrincipal, ErrorResult& aRv)
+{
+  return ReadHelper(aCx, aSubjectPrincipal, eRead, aRv);
+}
+
+already_AddRefed<Promise>
+Clipboard::ReadText(JSContext* aCx, nsIPrincipal& aSubjectPrincipal, ErrorResult& aRv)
+{
+  return ReadHelper(aCx, aSubjectPrincipal, eReadText, aRv);
+}
+
+already_AddRefed<Promise>
+Clipboard::Write(JSContext* aCx, DataTransfer& aData, nsIPrincipal& aSubjectPrincipal,
+                 ErrorResult& aRv)
+{
+  // Create a promise
+  RefPtr<Promise> p = dom::Promise::Create(GetOwnerGlobal(), aRv);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+
+  // We want to disable security check for automated tests that have the pref
+  //  dom.events.testing.asyncClipboard set to true
+  if (!IsTestingPrefEnabled() && !nsContentUtils::IsCutCopyAllowed(&aSubjectPrincipal)) {
+    MOZ_LOG(GetClipboardLog(), LogLevel::Debug,
+            ("Clipboard, Write, Not allowed to write to clipboard\n"));
+    p->MaybeRejectWithUndefined();
+    return p.forget();
+  }
+
+  // Get the clipboard service
+  nsCOMPtr<nsIClipboard> clipboard(do_GetService("@mozilla.org/widget/clipboard;1"));
+  if (!clipboard) {
+    p->MaybeRejectWithUndefined();
+    return p.forget();
+  }
+
+  nsPIDOMWindowInner* owner = GetOwner();
+  nsIDocument* doc          = owner ? owner->GetDoc() : nullptr;
+  nsILoadContext* context   = doc ? doc->GetLoadContext() : nullptr;
+  if (!context) {
+    p->MaybeRejectWithUndefined();
+    return p.forget();
+  }
+
+  // Get the transferable
+  RefPtr<nsITransferable> transferable = aData.GetTransferable(0, context);
+  if (!transferable) {
+    p->MaybeRejectWithUndefined();
+    return p.forget();
+  }
+
+  // Create a runnable
+  RefPtr<nsIRunnable> r = NS_NewRunnableFunction(
+    "Clipboard::Write",
+    [transferable, p, clipboard]() {
+      nsresult rv = clipboard->SetData(transferable,
+                                       /* owner of the transferable */ nullptr,
+                                       nsIClipboard::kGlobalClipboard);
+      if (NS_FAILED(rv)) {
+        p->MaybeRejectWithUndefined();
+        return;
+      }
+      p->MaybeResolveWithUndefined();
+      return;
+    });
+  // Dispatch the runnable
+  GetParentObject()->Dispatch(TaskCategory::Other, r.forget());
+  return p.forget();
+}
+
+already_AddRefed<Promise>
+Clipboard::WriteText(JSContext* aCx, const nsAString& aData,
+                     nsIPrincipal& aSubjectPrincipal, ErrorResult& aRv)
+{
+  // We create a data transfer with text/plain format so that
+  //  we can reuse Clipboard::Write(...) member function
+  RefPtr<DataTransfer> dataTransfer = new DataTransfer(this, eCopy,
+                                                      /* is external */ true,
+                                                      /* clipboard type */ -1);
+  dataTransfer->SetData(NS_LITERAL_STRING(kTextMime), aData, aSubjectPrincipal, aRv);
+  return Write(aCx, *dataTransfer, aSubjectPrincipal, aRv);
+}
+
+JSObject*
+Clipboard::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  return Clipboard_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+/* static */ LogModule*
+Clipboard::GetClipboardLog()
+{
+  return gClipboardLog;
+}
+
+bool
+Clipboard::IsTestingPrefEnabled()
+{
+  static bool sPrefCached = false;
+  static bool sPrefCacheValue = false;
+
+  if (!sPrefCached) {
+    sPrefCached = true;
+    Preferences::AddBoolVarCache(&sPrefCacheValue, "dom.events.testing.asyncClipboard");
+  }
+  MOZ_LOG(GetClipboardLog(), LogLevel::Debug,
+            ("Clipboard, Is testing enabled? %d\n", sPrefCacheValue));
+  return sPrefCacheValue;
+}
+
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(Clipboard)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(Clipboard,
+                                                  DOMEventTargetHelper)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(Clipboard,
+                                                DOMEventTargetHelper)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Clipboard)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+NS_IMPL_ADDREF_INHERITED(Clipboard, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(Clipboard, DOMEventTargetHelper)
+
+} // namespace dom
+} // namespace mozilla
new file mode 100644
--- /dev/null
+++ b/dom/events/Clipboard.h
@@ -0,0 +1,68 @@
+/* -*- 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_dom_Clipboard_h_
+#define mozilla_dom_Clipboard_h_
+
+#include "nsString.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/Logging.h"
+#include "mozilla/dom/DataTransfer.h"
+
+namespace mozilla {
+namespace dom {
+
+enum ClipboardReadType {
+  eRead,
+  eReadText,
+};
+
+class Promise;
+
+// https://www.w3.org/TR/clipboard-apis/#clipboard-interface
+class Clipboard : public DOMEventTargetHelper
+{
+public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(Clipboard,
+                                           DOMEventTargetHelper)
+
+  IMPL_EVENT_HANDLER(message)
+  IMPL_EVENT_HANDLER(messageerror)
+
+  explicit Clipboard(nsPIDOMWindowInner* aWindow);
+  already_AddRefed<Promise> Read(JSContext* aCx, nsIPrincipal& aSubjectPrincipal,
+                                 ErrorResult& aRv);
+  already_AddRefed<Promise> ReadText(JSContext* aCx, nsIPrincipal& aSubjectPrincipal,
+                                     ErrorResult& aRv);
+  already_AddRefed<Promise> Write(JSContext* aCx, DataTransfer& aData,
+                                  nsIPrincipal& aSubjectPrincipal, ErrorResult& aRv);
+  already_AddRefed<Promise> WriteText(JSContext* aCx, const nsAString& aData,
+                                    nsIPrincipal& aSubjectPrincipal, ErrorResult& aRv);
+
+  static LogModule* GetClipboardLog();
+
+
+  virtual JSObject*
+  WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+private:
+  // Checks if dom.events.testing.asyncClipboard pref is enabled.
+  // The aforementioned pref allows automated tests to bypass the security checks when writing to
+  //  or reading from the clipboard.
+  bool IsTestingPrefEnabled();
+
+  already_AddRefed<Promise> ReadHelper(JSContext* aCx, nsIPrincipal& aSubjectPrincipal,
+                                       ClipboardReadType aClipboardReadType, ErrorResult& aRv);
+
+  ~Clipboard();
+
+
+};
+
+} // namespace dom
+} // namespace mozilla
+#endif // mozilla_dom_Clipboard_h_
--- a/dom/events/DataTransfer.cpp
+++ b/dom/events/DataTransfer.cpp
@@ -1172,38 +1172,34 @@ DataTransfer::ConvertFromVariant(nsIVari
       ptrSupports.forget(aSupports);
 
       *aLength = sizeof(nsISupportsInterfacePointer *);
     }
 
     return true;
   }
 
-  char16_t* chrs;
-  uint32_t len = 0;
-  nsresult rv = aVariant->GetAsWStringWithSize(&len, &chrs);
+  nsAutoString str;
+  nsresult rv = aVariant->GetAsAString(str);
   if (NS_FAILED(rv)) {
     return false;
   }
 
-  nsAutoString str;
-  str.Adopt(chrs, len);
-
   nsCOMPtr<nsISupportsString>
     strSupports(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID));
   if (!strSupports) {
     return false;
   }
 
   strSupports->SetData(str);
 
   strSupports.forget(aSupports);
 
   // each character is two bytes
-  *aLength = str.Length() << 1;
+  *aLength = str.Length() * 2;
 
   return true;
 }
 
 void
 DataTransfer::Disconnect()
 {
   SetMode(Mode::Protected);
@@ -1381,19 +1377,17 @@ void
 DataTransfer::CacheExternalClipboardFormats(bool aPlainTextOnly)
 {
   // Called during the constructor for paste events to cache the formats
   // available on the clipboard. As with CacheExternalDragFormats, the
   // data will only be retrieved when needed.
   NS_ASSERTION(mEventMessage == ePaste,
                "caching clipboard data for invalid event");
 
-  nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
-  nsCOMPtr<nsIPrincipal> sysPrincipal;
-  ssm->GetSystemPrincipal(getter_AddRefs(sysPrincipal));
+  nsCOMPtr<nsIPrincipal> sysPrincipal = nsContentUtils::GetSystemPrincipal();
 
   nsTArray<nsCString> typesArray;
 
   if (XRE_IsContentProcess()) {
     ContentChild::GetSingleton()->SendGetExternalClipboardFormats(mClipboardType, aPlainTextOnly, &typesArray);
   } else {
     GetExternalClipboardFormats(mClipboardType, aPlainTextOnly, &typesArray);
   }
--- a/dom/events/DataTransfer.h
+++ b/dom/events/DataTransfer.h
@@ -446,16 +446,17 @@ protected:
   nsresult GetDataAtInternal(const nsAString& aFormat, uint32_t aIndex,
                              nsIPrincipal* aSubjectPrincipal,
                              nsIVariant** aData);
 
   nsresult SetDataAtInternal(const nsAString& aFormat, nsIVariant* aData,
                              uint32_t aIndex, nsIPrincipal* aSubjectPrincipal);
 
   friend class ContentParent;
+  friend class Clipboard;
 
   void FillAllExternalData();
 
   void FillInExternalCustomTypes(uint32_t aIndex, nsIPrincipal* aPrincipal);
 
   void FillInExternalCustomTypes(nsIVariant* aData, uint32_t aIndex,
                                  nsIPrincipal* aPrincipal);
 
--- a/dom/events/DataTransferItem.h
+++ b/dom/events/DataTransferItem.h
@@ -98,16 +98,17 @@ public:
     return mPrincipal;
   }
   void SetPrincipal(nsIPrincipal* aPrincipal)
   {
     mPrincipal = aPrincipal;
   }
 
   already_AddRefed<nsIVariant> DataNoSecurityCheck();
+  // Data may return null if the clipboard state has changed since the type was detected.
   already_AddRefed<nsIVariant> Data(nsIPrincipal* aPrincipal, ErrorResult& aRv);
 
   // Note: This can modify the mKind.  Callers of this method must let the
   // relevant DataTransfer know, because its types list can change as a result.
   void SetData(nsIVariant* aData);
 
   uint32_t Index() const
   {
--- a/dom/events/DataTransferItemList.cpp
+++ b/dom/events/DataTransferItemList.cpp
@@ -147,17 +147,18 @@ DataTransferItemList::Add(const nsAStrin
                           const nsAString& aType,
                           nsIPrincipal& aSubjectPrincipal,
                           ErrorResult& aRv)
 {
   if (NS_WARN_IF(mDataTransfer->IsReadOnly())) {
     return nullptr;
   }
 
-  nsCOMPtr<nsIVariant> data(new storage::TextVariant(aData));
+  RefPtr<nsVariantCC> data(new nsVariantCC());
+  data->SetAsAString(aData);
 
   nsAutoString format;
   mDataTransfer->GetRealFormat(aType, format);
 
   if (!DataTransfer::PrincipalMaySetData(format, data, &aSubjectPrincipal)) {
     aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
     return nullptr;
   }
--- a/dom/events/Event.cpp
+++ b/dom/events/Event.cpp
@@ -4,16 +4,17 @@
  * 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 "AccessCheck.h"
 #include "base/basictypes.h"
 #include "ipc/IPCMessageUtils.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/ShadowRoot.h"
+#include "mozilla/EventDispatcher.h"
 #include "mozilla/ContentEvents.h"
 #include "mozilla/DOMEventTargetHelper.h"
 #include "mozilla/EventStateManager.h"
 #include "mozilla/InternalMutationEvent.h"
 #include "mozilla/dom/Performance.h"
 #include "mozilla/dom/WorkerPrivate.h"
 #include "mozilla/MiscEvents.h"
 #include "mozilla/MouseEvents.h"
--- a/dom/events/moz.build
+++ b/dom/events/moz.build
@@ -42,16 +42,17 @@ EXPORTS.mozilla += [
     'TextComposition.h',
     'VirtualKeyCodeList.h',
     'WheelHandlingHelper.h',
 ]
 
 EXPORTS.mozilla.dom += [
     'AnimationEvent.h',
     'BeforeUnloadEvent.h',
+    'Clipboard.h',
     'ClipboardEvent.h',
     'CommandEvent.h',
     'CompositionEvent.h',
     'ConstructibleEventTarget.h',
     'CustomEvent.h',
     'DataTransfer.h',
     'DataTransferItem.h',
     'DataTransferItemList.h',
@@ -85,16 +86,17 @@ EXPORTS.mozilla.dom += [
 
 if CONFIG['MOZ_WEBSPEECH']:
     EXPORTS.mozilla.dom += ['SpeechRecognitionError.h']
 
 UNIFIED_SOURCES += [
     'AnimationEvent.cpp',
     'AsyncEventDispatcher.cpp',
     'BeforeUnloadEvent.cpp',
+    'Clipboard.cpp',
     'ClipboardEvent.cpp',
     'CommandEvent.cpp',
     'CompositionEvent.cpp',
     'ConstructibleEventTarget.cpp',
     'ContentEventHandler.cpp',
     'CustomEvent.cpp',
     'DataTransfer.cpp',
     'DataTransferItem.cpp',
--- a/dom/html/HTMLFormElement.cpp
+++ b/dom/html/HTMLFormElement.cpp
@@ -173,23 +173,16 @@ HTMLFormElement::Elements()
 }
 
 nsresult
 HTMLFormElement::BeforeSetAttr(int32_t aNamespaceID, nsAtom* aName,
                                const nsAttrValueOrString* aValue, bool aNotify)
 {
   if (aNamespaceID == kNameSpaceID_None) {
     if (aName == nsGkAtoms::action || aName == nsGkAtoms::target) {
-      if (mPendingSubmission) {
-        // aha, there is a pending submission that means we're in
-        // the script and we need to flush it. let's tell it
-        // that the event was ignored to force the flush.
-        // the second argument is not playing a role at all.
-        FlushPendingSubmission();
-      }
       // Don't forget we've notified the password manager already if the
       // page sets the action/target in the during submit. (bug 343182)
       bool notifiedObservers = mNotifiedObservers;
       ForgetCurrentSubmission();
       mNotifiedObservers = notifiedObservers;
     }
   }
 
@@ -675,25 +668,18 @@ HTMLFormElement::BuildSubmission(HTMLFor
 
   return NS_OK;
 }
 
 nsresult
 HTMLFormElement::SubmitSubmission(HTMLFormSubmission* aFormSubmission)
 {
   nsresult rv;
-  Element* originatingElement = aFormSubmission->GetOriginatingElement();
 
-  //
-  // Get the action and target
-  //
-  nsCOMPtr<nsIURI> actionURI;
-  rv = GetActionURL(getter_AddRefs(actionURI), originatingElement);
-  NS_ENSURE_SUBMIT_SUCCESS(rv);
-
+  nsCOMPtr<nsIURI> actionURI = aFormSubmission->GetActionURL();
   if (!actionURI) {
     mIsSubmitting = false;
     return NS_OK;
   }
 
   // If there is no link handler, then we won't actually be able to submit.
   nsIDocument* doc = GetComposedDoc();
   nsCOMPtr<nsISupports> container = doc ? doc->GetContainer() : nullptr;
@@ -715,31 +701,16 @@ HTMLFormElement::SubmitSubmission(HTMLFo
   // we're not submitting when submitting to a JS URL.  That's kinda bogus, but
   // there we are.
   bool schemeIsJavaScript = false;
   if (NS_SUCCEEDED(actionURI->SchemeIs("javascript", &schemeIsJavaScript)) &&
       schemeIsJavaScript) {
     mIsSubmitting = false;
   }
 
-  // The target is the originating element formtarget attribute if the element
-  // is a submit control and has such an attribute.
-  // Otherwise, the target is the form owner's target attribute,
-  // if it has such an attribute.
-  // Finally, if one of the child nodes of the head element is a base element
-  // with a target attribute, then the value of the target attribute of the
-  // first such base element; or, if there is no such element, the empty string.
-  nsAutoString target;
-  if (!(originatingElement && originatingElement->GetAttr(kNameSpaceID_None,
-                                                          nsGkAtoms::formtarget,
-                                                          target)) &&
-      !GetAttr(kNameSpaceID_None, nsGkAtoms::target, target)) {
-    GetBaseTarget(target);
-  }
-
   //
   // Notify observers of submit
   //
   bool cancelSubmit = false;
   if (mNotifiedObservers) {
     cancelSubmit = mNotifiedObserversResult;
   } else {
     rv = NotifySubmitObservers(actionURI, &cancelSubmit, true);
@@ -773,16 +744,18 @@ HTMLFormElement::SubmitSubmission(HTMLFo
                                        nullptr, doc);
 
     nsCOMPtr<nsIInputStream> postDataStream;
     rv = aFormSubmission->GetEncodedSubmission(actionURI,
                                                getter_AddRefs(postDataStream),
                                                actionURI);
     NS_ENSURE_SUBMIT_SUCCESS(rv);
 
+    nsAutoString target;
+    aFormSubmission->GetTarget(target);
     rv = linkHandler->OnLinkClickSync(this, actionURI,
                                       target.get(),
                                       VoidString(),
                                       postDataStream,
                                       nullptr, false,
                                       getter_AddRefs(docShell),
                                       getter_AddRefs(mSubmittingRequest),
                                       EventStateManager::IsHandlingUserInput());
--- a/dom/html/HTMLFormElement.h
+++ b/dom/html/HTMLFormElement.h
@@ -506,24 +506,16 @@ protected:
 
   /**
    * Find form controls in this form with the correct value in the name
    * attribute.
    */
   already_AddRefed<nsISupports> DoResolveName(const nsAString& aName, bool aFlushContent);
 
   /**
-   * Get the full URL to submit to.  Do not submit if the returned URL is null.
-   *
-   * @param aActionURL the full, unadulterated URL you'll be submitting to [OUT]
-   * @param aOriginatingElement the originating element of the form submission [IN]
-   */
-  nsresult GetActionURL(nsIURI** aActionURL, Element* aOriginatingElement);
-
-  /**
    * Check the form validity following this algorithm:
    * http://www.whatwg.org/specs/web-apps/current-work/#statically-validate-the-constraints
    *
    * @param aInvalidElements [out] parameter containing the list of unhandled
    * invalid controls.
    *
    * @return Whether the form is currently valid.
    */
@@ -552,16 +544,24 @@ protected:
 public:
   /**
    * Flush a possible pending submission. If there was a scripted submission
    * triggered by a button or image, the submission was defered. This method
    * forces the pending submission to be submitted. (happens when the handler
    * returns false or there is an action/target change in the script)
    */
   void FlushPendingSubmission();
+
+  /**
+   * Get the full URL to submit to.  Do not submit if the returned URL is null.
+   *
+   * @param aActionURL the full, unadulterated URL you'll be submitting to [OUT]
+   * @param aOriginatingElement the originating element of the form submission [IN]
+   */
+  nsresult GetActionURL(nsIURI** aActionURL, Element* aOriginatingElement);
 protected:
 
   //
   // Data members
   //
   /** The list of controls (form.elements as well as stuff not in elements) */
   RefPtr<HTMLFormControlsCollection> mControls;
   /** The currently selected radio button of each group */
--- a/dom/html/HTMLFormSubmission.cpp
+++ b/dom/html/HTMLFormSubmission.cpp
@@ -87,21 +87,23 @@ RetrieveDirectoryName(Directory* aDirect
 class FSURLEncoded : public EncodingFormSubmission
 {
 public:
   /**
    * @param aEncoding the character encoding of the form
    * @param aMethod the method of the submit (either NS_FORM_METHOD_GET or
    *        NS_FORM_METHOD_POST).
    */
-  FSURLEncoded(NotNull<const Encoding*> aEncoding,
+  FSURLEncoded(nsIURI* aActionURL,
+               const nsAString& aTarget,
+               NotNull<const Encoding*> aEncoding,
                int32_t aMethod,
                nsIDocument* aDocument,
                Element* aOriginatingElement)
-    : EncodingFormSubmission(aEncoding, aOriginatingElement)
+    : EncodingFormSubmission(aActionURL, aTarget, aEncoding, aOriginatingElement)
     , mMethod(aMethod)
     , mDocument(aDocument)
     , mWarnedFileControl(false)
   {
   }
 
   virtual nsresult
   AddNameValuePair(const nsAString& aName, const nsAString& aValue) override;
@@ -390,19 +392,21 @@ FSURLEncoded::URLEncode(const nsAString&
 
   return NS_OK;
 }
 
 } // anonymous namespace
 
 // --------------------------------------------------------------------------
 
-FSMultipartFormData::FSMultipartFormData(NotNull<const Encoding*> aEncoding,
+FSMultipartFormData::FSMultipartFormData(nsIURI* aActionURL,
+                                         const nsAString& aTarget,
+                                         NotNull<const Encoding*> aEncoding,
                                          Element* aOriginatingElement)
-  : EncodingFormSubmission(aEncoding, aOriginatingElement)
+  : EncodingFormSubmission(aActionURL, aTarget, aEncoding, aOriginatingElement)
 {
   mPostData =
     do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1");
 
   nsCOMPtr<nsIInputStream> inputStream = do_QueryInterface(mPostData);
   MOZ_ASSERT(SameCOMIdentity(mPostData, inputStream));
   mPostDataStream = inputStream;
 
@@ -664,19 +668,21 @@ FSMultipartFormData::AddPostDataStream()
 
 // --------------------------------------------------------------------------
 
 namespace {
 
 class FSTextPlain : public EncodingFormSubmission
 {
 public:
-  FSTextPlain(NotNull<const Encoding*> aEncoding,
+  FSTextPlain(nsIURI* aActionURL,
+              const nsAString& aTarget,
+              NotNull<const Encoding*> aEncoding,
               Element* aOriginatingElement)
-    : EncodingFormSubmission(aEncoding, aOriginatingElement)
+    : EncodingFormSubmission(aActionURL, aTarget, aEncoding, aOriginatingElement)
   {
   }
 
   virtual nsresult
   AddNameValuePair(const nsAString& aName, const nsAString& aValue) override;
 
   virtual nsresult
   AddNameBlobOrNullPair(const nsAString& aName, Blob* aBlob) override;
@@ -789,19 +795,21 @@ FSTextPlain::GetEncodedSubmission(nsIURI
   return rv;
 }
 
 } // anonymous namespace
 
 // --------------------------------------------------------------------------
 
 EncodingFormSubmission::EncodingFormSubmission(
+  nsIURI* aActionURL,
+  const nsAString& aTarget,
   NotNull<const Encoding*> aEncoding,
   Element* aOriginatingElement)
-  : HTMLFormSubmission(aEncoding, aOriginatingElement)
+  : HTMLFormSubmission(aActionURL, aTarget, aEncoding, aOriginatingElement)
 {
   if (!aEncoding->CanEncodeEverything()) {
     nsAutoCString name;
     aEncoding->Name(name);
     NS_ConvertUTF8toUTF16 nameUtf16(name);
     const char16_t* namePtr = nameUtf16.get();
     SendJSWarning(aOriginatingElement ? aOriginatingElement->GetOwnerDocument()
                                       : nullptr,
@@ -888,24 +896,47 @@ GetEnumAttr(nsGenericHTMLElement* aConte
   if (value && value->Type() == nsAttrValue::eEnum) {
     *aValue = value->GetEnumValue();
   }
 }
 
 } // anonymous namespace
 
 /* static */ nsresult
-HTMLFormSubmission::GetFromForm(nsGenericHTMLElement* aForm,
+HTMLFormSubmission::GetFromForm(HTMLFormElement* aForm,
                                 nsGenericHTMLElement* aOriginatingElement,
                                 HTMLFormSubmission** aFormSubmission)
 {
   // Get all the information necessary to encode the form data
   NS_ASSERTION(aForm->GetComposedDoc(),
                "Should have doc if we're building submission!");
 
+  nsresult rv;
+
+  // Get action
+  nsCOMPtr<nsIURI> actionURL;
+  rv = aForm->GetActionURL(getter_AddRefs(actionURL), aOriginatingElement);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get target
+  // The target is the originating element formtarget attribute if the element
+  // is a submit control and has such an attribute.
+  // Otherwise, the target is the form owner's target attribute,
+  // if it has such an attribute.
+  // Finally, if one of the child nodes of the head element is a base element
+  // with a target attribute, then the value of the target attribute of the
+  // first such base element; or, if there is no such element, the empty string.
+  nsAutoString target;
+  if (!(aOriginatingElement && aOriginatingElement->GetAttr(kNameSpaceID_None,
+                                                            nsGkAtoms::formtarget,
+                                                            target)) &&
+      !aForm->GetAttr(kNameSpaceID_None, nsGkAtoms::target, target)) {
+    aForm->GetBaseTarget(target);
+  }
+
   // Get encoding type (default: urlencoded)
   int32_t enctype = NS_FORM_ENCTYPE_URLENCODED;
   if (aOriginatingElement &&
       aOriginatingElement->HasAttr(kNameSpaceID_None, nsGkAtoms::formenctype)) {
     GetEnumAttr(aOriginatingElement, nsGkAtoms::formenctype, &enctype);
   } else {
     GetEnumAttr(aForm, nsGkAtoms::enctype, &enctype);
   }
@@ -920,20 +951,20 @@ HTMLFormSubmission::GetFromForm(nsGeneri
   }
 
   // Get encoding
   auto encoding = GetSubmitEncoding(aForm)->OutputEncoding();
 
   // Choose encoder
   if (method == NS_FORM_METHOD_POST &&
       enctype == NS_FORM_ENCTYPE_MULTIPART) {
-    *aFormSubmission = new FSMultipartFormData(encoding, aOriginatingElement);
+    *aFormSubmission = new FSMultipartFormData(actionURL, target, encoding, aOriginatingElement);
   } else if (method == NS_FORM_METHOD_POST &&
              enctype == NS_FORM_ENCTYPE_TEXTPLAIN) {
-    *aFormSubmission = new FSTextPlain(encoding, aOriginatingElement);
+    *aFormSubmission = new FSTextPlain(actionURL, target, encoding, aOriginatingElement);
   } else {
     nsIDocument* doc = aForm->OwnerDoc();
     if (enctype == NS_FORM_ENCTYPE_MULTIPART ||
         enctype == NS_FORM_ENCTYPE_TEXTPLAIN) {
       nsAutoString enctypeStr;
       if (aOriginatingElement &&
           aOriginatingElement->HasAttr(kNameSpaceID_None,
                                        nsGkAtoms::formenctype)) {
@@ -942,16 +973,16 @@ HTMLFormSubmission::GetFromForm(nsGeneri
       } else {
         aForm->GetAttr(kNameSpaceID_None, nsGkAtoms::enctype, enctypeStr);
       }
       const char16_t* enctypeStrPtr = enctypeStr.get();
       SendJSWarning(doc, "ForgotPostWarning",
                     &enctypeStrPtr, 1);
     }
     *aFormSubmission =
-      new FSURLEncoded(encoding, method, doc, aOriginatingElement);
+      new FSURLEncoded(actionURL, target, encoding, method, doc, aOriginatingElement);
   }
 
   return NS_OK;
 }
 
 } // dom namespace
 } // mozilla namespace
--- a/dom/html/HTMLFormSubmission.h
+++ b/dom/html/HTMLFormSubmission.h
@@ -18,16 +18,17 @@ class nsIInputStream;
 class nsGenericHTMLElement;
 class nsIMultiplexInputStream;
 
 namespace mozilla {
 namespace dom {
 
 class Blob;
 class Directory;
+class HTMLFormElement;
 
 /**
  * Class for form submissions; encompasses the function to call to submit as
  * well as the form submission name/value pairs
  */
 class HTMLFormSubmission
 {
 public:
@@ -35,17 +36,17 @@ public:
    * Get a submission object based on attributes in the form (ENCTYPE and
    * METHOD)
    *
    * @param aForm the form to get a submission object based on
    * @param aOriginatingElement the originating element (can be null)
    * @param aFormSubmission the form submission object (out param)
    */
   static nsresult
-  GetFromForm(nsGenericHTMLElement* aForm,
+  GetFromForm(HTMLFormElement* aForm,
               nsGenericHTMLElement* aOriginatingElement,
               HTMLFormSubmission** aFormSubmission);
 
   virtual ~HTMLFormSubmission()
   {
     MOZ_COUNT_DTOR(HTMLFormSubmission);
   }
 
@@ -95,42 +96,70 @@ public:
    */
   void GetCharset(nsACString& aCharset) { mEncoding->Name(aCharset); }
 
   Element* GetOriginatingElement() const
   {
     return mOriginatingElement.get();
   }
 
+  /**
+   * Get the action URI that will be used for submission.
+   */
+  nsIURI* GetActionURL() const
+  {
+    return mActionURL;
+  }
+
+  /**
+   * Get the target that will be used for submission.
+   */
+  void GetTarget(nsAString& aTarget)
+  {
+    aTarget = mTarget;
+  }
+
 protected:
   /**
    * Can only be constructed by subclasses.
    *
    * @param aEncoding the character encoding of the form
    * @param aOriginatingElement the originating element (can be null)
    */
-  HTMLFormSubmission(mozilla::NotNull<const mozilla::Encoding*> aEncoding,
+  HTMLFormSubmission(nsIURI* aActionURL,
+                     const nsAString& aTarget,
+                     mozilla::NotNull<const mozilla::Encoding*> aEncoding,
                      Element* aOriginatingElement)
-    : mEncoding(aEncoding)
+    : mActionURL(aActionURL)
+    , mTarget(aTarget)
+    , mEncoding(aEncoding)
     , mOriginatingElement(aOriginatingElement)
   {
     MOZ_COUNT_CTOR(HTMLFormSubmission);
   }
 
+  // The action url.
+  nsCOMPtr<nsIURI> mActionURL;
+
+  // The target.
+  nsString mTarget;
+
   // The character encoding of this form submission
   mozilla::NotNull<const mozilla::Encoding*> mEncoding;
 
   // Originating element.
   RefPtr<Element> mOriginatingElement;
 };
 
 class EncodingFormSubmission : public HTMLFormSubmission
 {
 public:
-  EncodingFormSubmission(mozilla::NotNull<const mozilla::Encoding*> aEncoding,
+  EncodingFormSubmission(nsIURI* aActionURL,
+                         const nsAString& aTarget,
+                         mozilla::NotNull<const mozilla::Encoding*> aEncoding,
                          Element* aOriginatingElement);
 
   virtual ~EncodingFormSubmission();
 
   /**
    * Encode a Unicode string to bytes using the encoder (or just copy the input
    * if there is no encoder).
    * @param aStr the string to encode
@@ -148,17 +177,19 @@ public:
  * inputs.  This always does POST.
  */
 class FSMultipartFormData : public EncodingFormSubmission
 {
 public:
   /**
    * @param aEncoding the character encoding of the form
    */
-  FSMultipartFormData(mozilla::NotNull<const mozilla::Encoding*> aEncoding,
+  FSMultipartFormData(nsIURI* aActionURL,
+                      const nsAString& aTarget,
+                      mozilla::NotNull<const mozilla::Encoding*> aEncoding,
                       Element* aOriginatingElement);
   ~FSMultipartFormData();
 
   virtual nsresult
   AddNameValuePair(const nsAString& aName, const nsAString& aValue) override;
 
   virtual nsresult
   AddNameBlobOrNullPair(const nsAString& aName, Blob* aBlob) override;
new file mode 100644
--- /dev/null
+++ b/dom/webidl/Clipboard.webidl
@@ -0,0 +1,24 @@
+/* -*- Mode: IDL; 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/.
+ *
+ * The origin of this IDL file is
+ * http://www.w3.org/TR/geolocation-API
+ *
+ * Copyright © 2018 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
+ * liability, trademark and document use rules apply.
+ */
+
+
+[SecureContext, Exposed=Window, Pref="dom.events.asyncClipboard"]
+interface Clipboard : EventTarget {
+  [Pref="dom.events.asyncClipboard.dataTransfer", Throws, NeedsSubjectPrincipal]
+  Promise<DataTransfer> read();
+  [Throws, NeedsSubjectPrincipal]
+  Promise<DOMString> readText();
+  [Pref="dom.events.asyncClipboard.dataTransfer", Throws, NeedsSubjectPrincipal]
+  Promise<void> write(DataTransfer data);
+  [Throws, NeedsSubjectPrincipal]
+  Promise<void> writeText(DOMString data);
+};
\ No newline at end of file
--- a/dom/webidl/Navigator.webidl
+++ b/dom/webidl/Navigator.webidl
@@ -326,8 +326,14 @@ partial interface Navigator {
 };
 
 // https://w3c.github.io/webdriver/webdriver-spec.html#interface
 [NoInterfaceObject]
 interface NavigatorAutomationInformation {
   [Pref="dom.webdriver.enabled"]
   readonly attribute boolean webdriver;
 };
+
+// https://www.w3.org/TR/clipboard-apis/#navigator-interface
+partial interface Navigator {
+  [Pref="dom.events.asyncClipboard", SecureContext, SameObject]
+  readonly attribute Clipboard clipboard;
+};
--- a/dom/webidl/moz.build
+++ b/dom/webidl/moz.build
@@ -53,16 +53,19 @@ with Files("Caret*"):
     BUG_COMPONENT = ("Core", "Editor")
 
 with Files("Channel*"):
     BUG_COMPONENT = ("Core", "Web Audio")
 
 with Files("Client*"):
     BUG_COMPONENT = ("Core", "DOM: Service Workers")
 
+with Files("Clipboard.webidl"):
+    BUG_COMPONENT = ("Core", "DOM: Events")
+
 with Files("ClipboardEvent.webidl"):
     BUG_COMPONENT = ("Core", "DOM: Events")
 
 with Files("ConstantSourceNode.webidl"):
     BUG_COMPONENT = ("Core", "Web Audio")
 
 with Files("ConvolverNode.webidl"):
     BUG_COMPONENT = ("Core", "Web Audio")
@@ -414,16 +417,17 @@ WEBIDL_FILES = [
     'ChannelSplitterNode.webidl',
     'CharacterData.webidl',
     'CheckerboardReportService.webidl',
     'ChildNode.webidl',
     'ChildSHistory.webidl',
     'ChromeNodeList.webidl',
     'Client.webidl',
     'Clients.webidl',
+    'Clipboard.webidl',
     'ClipboardEvent.webidl',
     'CommandEvent.webidl',
     'Comment.webidl',
     'CompositionEvent.webidl',
     'Console.webidl',
     'ConstantSourceNode.webidl',
     'ConvolverNode.webidl',
     'Coordinates.webidl',
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -449,21 +449,20 @@ CompositorBridgeParent::~CompositorBridg
   // We expect all textures to be destroyed by now.
   MOZ_DIAGNOSTIC_ASSERT(textures.Length() == 0);
   for (unsigned int i = 0; i < textures.Length(); ++i) {
     RefPtr<TextureHost> tex = TextureHost::AsTextureHost(textures[i]);
     tex->DeallocateDeviceData();
   }
 }
 
-mozilla::ipc::IPCResult
-CompositorBridgeParent::RecvForceIsFirstPaint()
+void
+CompositorBridgeParent::ForceIsFirstPaint()
 {
   mCompositionManager->ForceIsFirstPaint();
-  return IPC_OK();
 }
 
 void
 CompositorBridgeParent::StopAndClearResources()
 {
   if (mForceCompositionTask) {
     mForceCompositionTask->Cancel();
     mForceCompositionTask = nullptr;
--- a/gfx/layers/ipc/CompositorBridgeParent.h
+++ b/gfx/layers/ipc/CompositorBridgeParent.h
@@ -287,17 +287,17 @@ public:
 
   /**
    * This forces the is-first-paint flag to true. This is intended to
    * be called by the widget code when it loses its viewport information
    * (or for whatever reason wants to refresh the viewport information).
    * The information refresh happens because the compositor will call
    * SetFirstPaintViewport on the next frame of composition.
    */
-  mozilla::ipc::IPCResult RecvForceIsFirstPaint() override;
+  void ForceIsFirstPaint();
 
   static void SetShadowProperties(Layer* aLayer);
 
   void NotifyChildCreated(LayersId aChild);
 
   void AsyncRender();
 
   // Can be called from any thread
--- a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
+++ b/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
@@ -36,17 +36,16 @@ public:
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
   // FIXME/bug 774388: work out what shutdown protocol we need.
   mozilla::ipc::IPCResult RecvInitialize(const LayersId& aRootLayerTreeId) override { return IPC_FAIL_NO_REASON(this); }
   mozilla::ipc::IPCResult RecvWillClose() override { return IPC_OK(); }
   mozilla::ipc::IPCResult RecvPause() override { return IPC_OK(); }
   mozilla::ipc::IPCResult RecvResume() override { return IPC_OK(); }
-  mozilla::ipc::IPCResult RecvForceIsFirstPaint() override { return IPC_OK(); }
   mozilla::ipc::IPCResult RecvNotifyChildCreated(const LayersId& child, CompositorOptions* aOptions) override;
   mozilla::ipc::IPCResult RecvMapAndNotifyChildCreated(const LayersId& child, const base::ProcessId& pid, CompositorOptions* aOptions) override;
   mozilla::ipc::IPCResult RecvNotifyChildRecreated(const LayersId& child, CompositorOptions* aOptions) override { return IPC_FAIL_NO_REASON(this); }
   mozilla::ipc::IPCResult RecvAdoptChild(const LayersId& child) override { return IPC_FAIL_NO_REASON(this); }
   mozilla::ipc::IPCResult RecvMakeSnapshot(const SurfaceDescriptor& aInSnapshot,
                                            const gfx::IntRect& aRect) override
   { return IPC_OK(); }
   mozilla::ipc::IPCResult RecvFlushRendering() override { return IPC_OK(); }
--- a/gfx/layers/ipc/PCompositorBridge.ipdl
+++ b/gfx/layers/ipc/PCompositorBridge.ipdl
@@ -159,17 +159,16 @@ parent:
 
   // The child is about to be destroyed, so perform any necessary cleanup.
   sync WillClose();
 
   // Pause/resume the compositor. These are intended to be used on mobile, when
   // the compositor needs to pause/resume in lockstep with the application.
   sync Pause();
   sync Resume();
-  async ForceIsFirstPaint();
 
   // See bug 1316632 comment #33 for why this has to be sync. Otherwise,
   // there are ordering issues with SendPLayerTransactionConstructor.
   sync NotifyChildCreated(LayersId id)
     returns (CompositorOptions compositorOptions);
 
   // This version of NotifyChildCreated also performs a layer tree mapping.
   //
--- a/gfx/layers/ipc/UiCompositorControllerParent.cpp
+++ b/gfx/layers/ipc/UiCompositorControllerParent.cpp
@@ -70,17 +70,17 @@ UiCompositorControllerParent::RecvResume
 
 mozilla::ipc::IPCResult
 UiCompositorControllerParent::RecvResumeAndResize(const int32_t& aWidth,
                                                   const int32_t& aHeight)
 {
   CompositorBridgeParent* parent = CompositorBridgeParent::GetCompositorBridgeParentFromLayersId(mRootLayerTreeId);
   if (parent) {
     // Front-end expects a first paint callback upon resume/resize.
-    parent->RecvForceIsFirstPaint();
+    parent->ForceIsFirstPaint();
     parent->ResumeCompositionAndResize(aWidth, aHeight);
   }
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 UiCompositorControllerParent::RecvInvalidateAndRender()
 {
--- a/gfx/skia/skia/src/ports/SkFontHost_cairo.cpp
+++ b/gfx/skia/skia/src/ports/SkFontHost_cairo.cpp
@@ -8,16 +8,17 @@
 
 #include "cairo.h"
 #include "cairo-ft.h"
 
 #include "SkFontHost_FreeType_common.h"
 
 #include "SkAdvancedTypefaceMetrics.h"
 #include "SkFDot6.h"
+#include "SkMutex.h"
 #include "SkPath.h"
 #include "SkScalerContext.h"
 #include "SkTypefaceCache.h"
 
 #include <cmath>
 
 #include <ft2build.h>
 #include FT_FREETYPE_H
@@ -164,16 +165,18 @@ static bool bothZero(SkScalar a, SkScala
 
 // returns false if there is any non-90-rotation or skew
 static bool isAxisAligned(const SkScalerContextRec& rec) {
     return 0 == rec.fPreSkewX &&
            (bothZero(rec.fPost2x2[0][1], rec.fPost2x2[1][0]) ||
             bothZero(rec.fPost2x2[0][0], rec.fPost2x2[1][1]));
 }
 
+SK_DECLARE_STATIC_MUTEX(gTypefaceMutex);
+
 class SkCairoFTTypeface : public SkTypeface {
 public:
     virtual SkStreamAsset* onOpenStream(int*) const override { return nullptr; }
 
     virtual std::unique_ptr<SkAdvancedTypefaceMetrics> onGetAdvancedMetrics() const override
     {
         SkDEBUGCODE(SkDebugf("SkCairoFTTypeface::onGetAdvancedMetrics unimplemented\n"));
         return nullptr;
@@ -264,19 +267,29 @@ public:
 #ifdef CAIRO_HAS_FC_FONT
         if (fPattern) {
             FcPatternReference(fPattern);
         }
 #endif
     }
 
 private:
+
+    void internal_dispose() const override
+    {
+        SkAutoMutexAcquire lock(gTypefaceMutex);
+        internal_dispose_restore_refcnt_to_1();
+        delete this;
+    }
+
     ~SkCairoFTTypeface()
     {
-        cairo_font_face_set_user_data(fFontFace, &kSkTypefaceKey, nullptr, nullptr);
+        if (cairo_font_face_get_user_data(fFontFace, &kSkTypefaceKey) == this) {
+            cairo_font_face_set_user_data(fFontFace, &kSkTypefaceKey, nullptr, nullptr);
+        }
         cairo_font_face_destroy(fFontFace);
 #ifdef CAIRO_HAS_FC_FONT
         if (fPattern) {
             FcPatternDestroy(fPattern);
         }
 #endif
     }
 
@@ -285,22 +298,23 @@ private:
 };
 
 SkTypeface* SkCreateTypefaceFromCairoFTFontWithFontconfig(cairo_scaled_font_t* scaledFont, FcPattern* pattern)
 {
     cairo_font_face_t* fontFace = cairo_scaled_font_get_font_face(scaledFont);
     SkASSERT(cairo_font_face_status(fontFace) == CAIRO_STATUS_SUCCESS);
     SkASSERT(cairo_font_face_get_type(fontFace) == CAIRO_FONT_TYPE_FT);
 
+    SkAutoMutexAcquire lock(gTypefaceMutex);
+
     SkTypeface* typeface = reinterpret_cast<SkTypeface*>(cairo_font_face_get_user_data(fontFace, &kSkTypefaceKey));
-    if (typeface) {
+    if (typeface && typeface->getRefCnt() > 0) {
         typeface->ref();
     } else {
         typeface = new SkCairoFTTypeface(fontFace, pattern);
-        SkTypefaceCache::Add(typeface);
     }
 
     return typeface;
 }
 
 SkTypeface* SkCreateTypefaceFromCairoFTFont(cairo_scaled_font_t* scaledFont)
 {
     return SkCreateTypefaceFromCairoFTFontWithFontconfig(scaledFont, nullptr);
--- a/gfx/thebes/gfxPrefs.h
+++ b/gfx/thebes/gfxPrefs.h
@@ -462,17 +462,17 @@ private:
   DECL_GFX_PREF(Once, "gfx.canvas.skiagl.dynamic-cache",       CanvasSkiaGLDynamicCache, bool, false);
 
   DECL_GFX_PREF(Live, "gfx.color_management.enablev4",         CMSEnableV4, bool, false);
   DECL_GFX_PREF(Live, "gfx.color_management.mode",             CMSMode, int32_t,-1);
   // The zero default here should match QCMS_INTENT_DEFAULT from qcms.h
   DECL_GFX_PREF(Live, "gfx.color_management.rendering_intent", CMSRenderingIntent, int32_t, 0);
   DECL_GFX_PREF(Live, "gfx.content.always-paint",              AlwaysPaint, bool, false);
   // Size in megabytes
-  DECL_GFX_PREF(Once, "gfx.content.skia-font-cache-size",      SkiaContentFontCacheSize, int32_t, 10);
+  DECL_GFX_PREF(Once, "gfx.content.skia-font-cache-size",      SkiaContentFontCacheSize, int32_t, 5);
 
   DECL_GFX_PREF(Once, "gfx.device-reset.limit",                DeviceResetLimitCount, int32_t, 10);
   DECL_GFX_PREF(Once, "gfx.device-reset.threshold-ms",         DeviceResetThresholdMilliseconds, int32_t, -1);
 
   DECL_GFX_PREF(Once, "gfx.direct2d.disabled",                 Direct2DDisabled, bool, false);
   DECL_GFX_PREF(Once, "gfx.direct2d.force-enabled",            Direct2DForceEnabled, bool, false);
   DECL_GFX_PREF(Live, "gfx.direct2d.destroy-dt-on-paintthread",Direct2DDestroyDTOnPaintThread, bool, true);
   DECL_GFX_PREF(Live, "gfx.direct3d11.reuse-decoder-device",   Direct3D11ReuseDecoderDevice, int32_t, -1);
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -4856,51 +4856,114 @@ ICUnaryArith_Fallback::Compiler::generat
     pushStubPayload(masm, R0.scratchReg());
 
     return tailCallVM(DoUnaryArithFallbackInfo, masm);
 }
 
 //
 // BinaryArith_Fallback
 //
-// This currently is fused with the SharedIC DoBinaryArithFallback, however,
-// as we deprecate the SharedIC, this will be able to eventually take over.
-//
-// At that point the stub argument will go away, and instead be generated here.
-bool
-DoCacheIRBinaryArithFallback(JSContext* cx, BaselineFrame* frame, ICBinaryArith_Fallback* stub_,
-                             HandleValue lhs, HandleValue rhs, MutableHandleValue ret,
-                             DebugModeOSRVolatileStub<ICBinaryArith_Fallback*>& stub)
+
+static bool
+DoBinaryArithFallback(JSContext* cx, BaselineFrame* frame, ICBinaryArith_Fallback* stub_,
+                      HandleValue lhs, HandleValue rhs, MutableHandleValue ret)
 {
+    // This fallback stub may trigger debug mode toggling.
+    DebugModeOSRVolatileStub<ICBinaryArith_Fallback*> stub(ICStubEngine::Baseline, frame, stub_);
+
     RootedScript script(cx, frame->script());
     jsbytecode* pc = stub->icEntry()->pc(script);
     JSOp op = JSOp(*pc);
-
-    // Ensure we're only generating for an enabled opcode.
-    switch(op) {
-      case JSOP_ADD:
-      case JSOP_SUB:
-      case JSOP_BITOR:
-      case JSOP_BITXOR:
-      case JSOP_BITAND:
-      case JSOP_MUL:
-      case JSOP_DIV:
-      case JSOP_MOD:
-      case JSOP_URSH:
-      case JSOP_RSH:
-      case JSOP_LSH:
-        break;
-      default:
-        return false; // Fallback to shared IC.
-    }
-
     FallbackICSpew(cx, stub, "CacheIRBinaryArith(%s,%d,%d)", CodeName[op],
             int(lhs.isDouble() ? JSVAL_TYPE_DOUBLE : lhs.extractNonDoubleType()),
             int(rhs.isDouble() ? JSVAL_TYPE_DOUBLE : rhs.extractNonDoubleType()));
 
+    // Don't pass lhs/rhs directly, we need the original values when
+    // generating stubs.
+    RootedValue lhsCopy(cx, lhs);
+    RootedValue rhsCopy(cx, rhs);
+
+    // Perform the compare operation.
+    switch(op) {
+      case JSOP_ADD:
+        // Do an add.
+        if (!AddValues(cx, &lhsCopy, &rhsCopy, ret))
+            return false;
+        break;
+      case JSOP_SUB:
+        if (!SubValues(cx, &lhsCopy, &rhsCopy, ret))
+            return false;
+        break;
+      case JSOP_MUL:
+        if (!MulValues(cx, &lhsCopy, &rhsCopy, ret))
+            return false;
+        break;
+      case JSOP_DIV:
+        if (!DivValues(cx, &lhsCopy, &rhsCopy, ret))
+            return false;
+        break;
+      case JSOP_MOD:
+        if (!ModValues(cx, &lhsCopy, &rhsCopy, ret))
+            return false;
+        break;
+      case JSOP_POW:
+        if (!PowValues(cx, &lhsCopy, &rhsCopy, ret))
+            return false;
+        break;
+      case JSOP_BITOR: {
+        int32_t result;
+        if (!BitOr(cx, lhs, rhs, &result))
+            return false;
+        ret.setInt32(result);
+        break;
+      }
+      case JSOP_BITXOR: {
+        int32_t result;
+        if (!BitXor(cx, lhs, rhs, &result))
+            return false;
+        ret.setInt32(result);
+        break;
+      }
+      case JSOP_BITAND: {
+        int32_t result;
+        if (!BitAnd(cx, lhs, rhs, &result))
+            return false;
+        ret.setInt32(result);
+        break;
+      }
+      case JSOP_LSH: {
+        int32_t result;
+        if (!BitLsh(cx, lhs, rhs, &result))
+            return false;
+        ret.setInt32(result);
+        break;
+      }
+      case JSOP_RSH: {
+        int32_t result;
+        if (!BitRsh(cx, lhs, rhs, &result))
+            return false;
+        ret.setInt32(result);
+        break;
+      }
+      case JSOP_URSH: {
+        if (!UrshOperation(cx, lhs, rhs, ret))
+            return false;
+        break;
+      }
+      default:
+        MOZ_CRASH("Unhandled baseline arith op");
+    }
+
+    // Check if debug mode toggling made the stub invalid.
+    if (stub.invalid())
+        return true;
+
+    if (ret.isDouble())
+        stub->setSawDoubleResult();
+
     // Check if debug mode toggling made the stub invalid.
     if (stub.invalid())
         return true;
 
     if (ret.isDouble())
         stub->setSawDoubleResult();
 
     if (stub->state().maybeTransition())
@@ -4911,18 +4974,46 @@ DoCacheIRBinaryArithFallback(JSContext* 
                                    op, lhs, rhs, ret);
         if (gen.tryAttachStub()) {
             bool attached = false;
             ICStub* newStub = AttachBaselineCacheIRStub(cx, gen.writerRef(), gen.cacheKind(),
                                                         BaselineCacheIRStubKind::Regular,
                                                         ICStubEngine::Baseline, script, stub, &attached);
             if (newStub)
                 JitSpew(JitSpew_BaselineIC, "  Attached BinaryArith CacheIR stub for %s", CodeName[op]);
+
         } else {
-            return false; // Fallback to shared IC.
+            stub->noteUnoptimizableOperands();
         }
     }
     return true;
 }
 
+typedef bool (*DoBinaryArithFallbackFn)(JSContext*, BaselineFrame*, ICBinaryArith_Fallback*,
+                                        HandleValue, HandleValue, MutableHandleValue);
+static const VMFunction DoBinaryArithFallbackInfo =
+    FunctionInfo<DoBinaryArithFallbackFn>(DoBinaryArithFallback, "DoBinaryArithFallback",
+                                          TailCall, PopValues(2));
+
+bool
+ICBinaryArith_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
+{
+    MOZ_ASSERT(R0 == JSReturnOperand);
+
+    // Restore the tail call register.
+    EmitRestoreTailCallReg(masm);
+
+    // Ensure stack is fully synced for the expression decompiler.
+    masm.pushValue(R0);
+    masm.pushValue(R1);
+
+    // Push arguments.
+    masm.pushValue(R1);
+    masm.pushValue(R0);
+    masm.push(ICStubReg);
+    pushStubPayload(masm, R0.scratchReg());
+
+    return tailCallVM(DoBinaryArithFallbackInfo, masm);
+}
+
 
 } // namespace jit
 } // namespace js
--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -1501,16 +1501,65 @@ class ICUnaryArith_Fallback : public ICF
         {}
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICUnaryArith_Fallback>(space, getStubCode());
         }
     };
 };
 
+// BinaryArith
+//      JSOP_ADD, JSOP_SUB, JSOP_MUL, JOP_DIV, JSOP_MOD
+//      JSOP_BITAND, JSOP_BITXOR, JSOP_BITOR
+//      JSOP_LSH, JSOP_RSH, JSOP_URSH
+
+class ICBinaryArith_Fallback : public ICFallbackStub
+{
+    friend class ICStubSpace;
+
+    explicit ICBinaryArith_Fallback(JitCode* stubCode)
+      : ICFallbackStub(BinaryArith_Fallback, stubCode)
+    {
+        extra_ = 0;
+    }
+
+    static const uint16_t SAW_DOUBLE_RESULT_BIT = 0x1;
+    static const uint16_t UNOPTIMIZABLE_OPERANDS_BIT = 0x2;
+
+  public:
+    static const uint32_t MAX_OPTIMIZED_STUBS = 8;
+
+    bool sawDoubleResult() const {
+        return extra_ & SAW_DOUBLE_RESULT_BIT;
+    }
+    void setSawDoubleResult() {
+        extra_ |= SAW_DOUBLE_RESULT_BIT;
+    }
+    bool hadUnoptimizableOperands() const {
+        return extra_ & UNOPTIMIZABLE_OPERANDS_BIT;
+    }
+    void noteUnoptimizableOperands() {
+        extra_ |= UNOPTIMIZABLE_OPERANDS_BIT;
+    }
+
+    // Compiler for this stub kind.
+    class Compiler : public ICStubCompiler {
+      protected:
+        MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
+
+      public:
+        explicit Compiler(JSContext* cx, Engine engine)
+          : ICStubCompiler(cx, ICStub::BinaryArith_Fallback, engine) {}
+
+        ICStub* getStub(ICStubSpace* space) override {
+            return newStub<ICBinaryArith_Fallback>(space, getStubCode());
+        }
+    };
+};
+
 inline bool
 IsCacheableDOMProxy(JSObject* obj)
 {
     if (!obj->is<ProxyObject>())
         return false;
 
     const BaseProxyHandler* handler = obj->as<ProxyObject>().handler();
     return handler->family() == GetDOMProxyHandlerFamily();
--- a/js/src/jit/BaselineInspector.cpp
+++ b/js/src/jit/BaselineInspector.cpp
@@ -400,28 +400,16 @@ BaselineInspector::expectedResultType(js
     // for bytecode ops that are unreachable and don't have a Baseline IC, see
     // comment in monomorphicStub.
 
     ICStub* stub = monomorphicStub(pc);
     if (!stub)
         return MIRType::None;
 
     switch (stub->kind()) {
-      case ICStub::BinaryArith_Int32:
-        if (stub->toBinaryArith_Int32()->allowDouble())
-            return MIRType::Double;
-        return MIRType::Int32;
-      case ICStub::BinaryArith_BooleanWithInt32:
-      case ICStub::BinaryArith_DoubleWithInt32:
-        return MIRType::Int32;
-      case ICStub::BinaryArith_Double:
-        return MIRType::Double;
-      case ICStub::BinaryArith_StringConcat:
-      case ICStub::BinaryArith_StringObjectConcat:
-        return MIRType::String;
       case ICStub::CacheIR_Regular:
         return ParseCacheIRStub(stub);
       default:
         return MIRType::None;
     }
 }
 
 // Whether a baseline stub kind is suitable for a double comparison that
@@ -493,28 +481,16 @@ TryToSpecializeBinaryArithOp(ICStub** st
                              MIRType* result)
 {
     DebugOnly<bool> sawInt32 = false;
     bool sawDouble = false;
     bool sawOther = false;
 
     for (uint32_t i = 0; i < nstubs; i++) {
         switch (stubs[i]->kind()) {
-          case ICStub::BinaryArith_Int32:
-            sawInt32 = true;
-            break;
-          case ICStub::BinaryArith_BooleanWithInt32:
-            sawInt32 = true;
-            break;
-          case ICStub::BinaryArith_Double:
-            sawDouble = true;
-            break;
-          case ICStub::BinaryArith_DoubleWithInt32:
-            sawDouble = true;
-            break;
           case ICStub::CacheIR_Regular:
             switch (ParseCacheIRStub(stubs[i])) {
               case MIRType::Double:
                 sawDouble = true;
                 break;
               case MIRType::Int32:
                 sawInt32 = true;
                 break;
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -10268,21 +10268,16 @@ CodeGenerator::generate()
 
 bool
 CodeGenerator::linkSharedStubs(JSContext* cx)
 {
     for (uint32_t i = 0; i < sharedStubs_.length(); i++) {
         ICStub *stub = nullptr;
 
         switch (sharedStubs_[i].kind) {
-          case ICStub::Kind::BinaryArith_Fallback: {
-            ICBinaryArith_Fallback::Compiler stubCompiler(cx, ICStubCompiler::Engine::IonSharedIC);
-            stub = stubCompiler.getStub(&stubSpace_);
-            break;
-          }
           case ICStub::Kind::Compare_Fallback: {
             ICCompare_Fallback::Compiler stubCompiler(cx, ICStubCompiler::Engine::IonSharedIC);
             stub = stubCompiler.getStub(&stubSpace_);
             break;
           }
           case ICStub::Kind::GetProp_Fallback: {
             ICGetProp_Fallback::Compiler stubCompiler(cx, ICStubCompiler::Engine::IonSharedIC);
             stub = stubCompiler.getStub(&stubSpace_);
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -3288,17 +3288,17 @@ IonBuilder::jsop_bitnot()
     MDefinition* input = current->pop();
 
     if (!forceInlineCaches()) {
         MOZ_TRY(bitnotTrySpecialized(&emitted, input));
         if(emitted)
             return Ok();
     }
 
-    MOZ_TRY(arithTrySharedStub(&emitted, JSOP_BITNOT, nullptr, input));
+    MOZ_TRY(arithTryBinaryStub(&emitted, JSOP_BITNOT, nullptr, input));
     if (emitted)
         return Ok();
 
     // Not possible to optimize. Do a slow vm call.
     MBitNot* ins = MBitNot::New(alloc(), input);
 
     current->add(ins);
     current->push(ins);
@@ -3539,54 +3539,46 @@ IonBuilder::binaryArithTrySpecializedOnB
     MOZ_TRY(maybeInsertResume());
 
     trackOptimizationSuccess();
     *emitted = true;
     return Ok();
 }
 
 AbortReasonOr<Ok>
-IonBuilder::arithTrySharedStub(bool* emitted, JSOp op,
+IonBuilder::arithTryBinaryStub(bool* emitted, JSOp op,
                                MDefinition* left, MDefinition* right)
 {
     MOZ_ASSERT(*emitted == false);
     JSOp actualOp = JSOp(*pc);
 
-    // Try to emit a shared stub cache.
-
-    if (JitOptions.disableSharedStubs)
+    // Try to emit a binary arith stub cache.
+    if (JitOptions.disableCacheIRBinaryArith)
         return Ok();
 
     // The actual jsop 'jsop_pos' is not supported yet.
-    if (actualOp == JSOP_POS)
-        return Ok();
-
+    // There's no IC support for JSOP_POW either.
+    if (actualOp == JSOP_POS || actualOp == JSOP_POW)
+        return Ok();
 
     MInstruction* stub = nullptr;
     switch (actualOp) {
       case JSOP_NEG:
       case JSOP_BITNOT:
         MOZ_ASSERT_IF(op == JSOP_MUL,
                       left->maybeConstantValue() && left->maybeConstantValue()->toInt32() == -1);
         MOZ_ASSERT_IF(op != JSOP_MUL, !left);
         stub = MUnaryCache::New(alloc(), right);
         break;
       case JSOP_ADD:
       case JSOP_SUB:
       case JSOP_MUL:
       case JSOP_DIV:
       case JSOP_MOD:
-        // If not disabled, prefer the cache IR stub.
-        if (!JitOptions.disableCacheIRBinaryArith) {
-            stub = MBinaryCache::New(alloc(), left, right);
-            break;
-        }
-        MOZ_FALLTHROUGH;
-      case JSOP_POW:
-        stub = MBinarySharedStub::New(alloc(), left, right);
+        stub = MBinaryCache::New(alloc(), left, right);
         break;
       default:
         MOZ_CRASH("unsupported arith");
     }
 
     current->add(stub);
     current->push(stub);
 
@@ -3619,17 +3611,17 @@ IonBuilder::jsop_binary_arith(JSOp op, M
         if (emitted)
             return Ok();
 
         MOZ_TRY(binaryArithTrySpecializedOnBaselineInspector(&emitted, op, left, right));
         if (emitted)
             return Ok();
     }
 
-    MOZ_TRY(arithTrySharedStub(&emitted, op, left, right));
+    MOZ_TRY(arithTryBinaryStub(&emitted, op, left, right));
     if (emitted)
         return Ok();
 
     // Not possible to optimize. Do a slow vm call.
     trackOptimizationAttempt(TrackedStrategy::BinaryArith_Call);
     trackOptimizationSuccess();
 
     MDefinition::Opcode def_op = JSOpToMDefinition(op);
@@ -3664,17 +3656,17 @@ IonBuilder::jsop_pow()
     bool emitted = false;
 
     if (!forceInlineCaches()) {
         MOZ_TRY(powTrySpecialized(&emitted, base, exponent, MIRType::Double));
         if (emitted)
             return Ok();
     }
 
-    MOZ_TRY(arithTrySharedStub(&emitted, JSOP_POW, base, exponent));
+    MOZ_TRY(arithTryBinaryStub(&emitted, JSOP_POW, base, exponent));
     if (emitted)
         return Ok();
 
     // For now, use MIRType::None as a safe cover-all. See bug 1188079.
     MPow* pow = MPow::New(alloc(), base, exponent, MIRType::None);
     current->add(pow);
     current->push(pow);
     MOZ_ASSERT(pow->isEffectful());
--- a/js/src/jit/IonBuilder.h
+++ b/js/src/jit/IonBuilder.h
@@ -309,17 +309,17 @@ class IonBuilder
     MBinaryArithInstruction* binaryArithInstruction(JSOp op, MDefinition* left, MDefinition* right);
     AbortReasonOr<Ok> binaryArithTryConcat(bool* emitted, JSOp op, MDefinition* left,
                                            MDefinition* right);
     AbortReasonOr<Ok> binaryArithTrySpecialized(bool* emitted, JSOp op, MDefinition* left,
                                                 MDefinition* right);
     AbortReasonOr<Ok> binaryArithTrySpecializedOnBaselineInspector(bool* emitted, JSOp op,
                                                                    MDefinition* left,
                                                                    MDefinition* right);
-    AbortReasonOr<Ok> arithTrySharedStub(bool* emitted, JSOp op, MDefinition* left,
+    AbortReasonOr<Ok> arithTryBinaryStub(bool* emitted, JSOp op, MDefinition* left,
                                          MDefinition* right);
 
     // jsop_bitnot helpers.
     AbortReasonOr<Ok> bitnotTrySpecialized(bool* emitted, MDefinition* input);
 
     // jsop_pow helpers.
     AbortReasonOr<Ok> powTrySpecialized(bool* emitted, MDefinition* base, MDefinition* power,
                                         MIRType outputType);
--- a/js/src/jit/SharedIC.cpp
+++ b/js/src/jit/SharedIC.cpp
@@ -666,541 +666,16 @@ SharedStubInfo::outerScript(JSContext* c
         MOZ_ASSERT(it.isIonJS());
         outerScript_ = it.script();
         MOZ_ASSERT(!it.ionScript()->invalidated());
     }
     return outerScript_;
 }
 
 //
-// BinaryArith_Fallback
-//
-// This will be phased out in favour of the CacheIR system.
-
-extern bool
-DoCacheIRBinaryArithFallback(JSContext* cx, BaselineFrame* frame, ICBinaryArith_Fallback* stub_,
-                             HandleValue lhs, HandleValue rhs, MutableHandleValue ret,
-                             DebugModeOSRVolatileStub<ICBinaryArith_Fallback*>& stub);
-
-static bool
-DoBinaryArithFallback(JSContext* cx, void* payload, ICBinaryArith_Fallback* stub_,
-                      HandleValue lhs, HandleValue rhs, MutableHandleValue ret)
-{
-    SharedStubInfo info(cx, payload, stub_->icEntry());
-    ICStubCompiler::Engine engine = info.engine();
-
-    // This fallback stub may trigger debug mode toggling.
-    DebugModeOSRVolatileStub<ICBinaryArith_Fallback*> stub(engine, info.maybeFrame(), stub_);
-
-    jsbytecode* pc = info.pc();
-    JSOp op = JSOp(*pc);
-    FallbackICSpew(cx, stub, "BinaryArith(%s,%d,%d)", CodeName[op],
-            int(lhs.isDouble() ? JSVAL_TYPE_DOUBLE : lhs.extractNonDoubleType()),
-            int(rhs.isDouble() ? JSVAL_TYPE_DOUBLE : rhs.extractNonDoubleType()));
-
-
-    // Don't pass lhs/rhs directly, we need the original values when
-    // generating stubs.
-    RootedValue lhsCopy(cx, lhs);
-    RootedValue rhsCopy(cx, rhs);
-
-    // Perform the compare operation.
-    switch(op) {
-      case JSOP_ADD:
-        // Do an add.
-        if (!AddValues(cx, &lhsCopy, &rhsCopy, ret))
-            return false;
-        break;
-      case JSOP_SUB:
-        if (!SubValues(cx, &lhsCopy, &rhsCopy, ret))
-            return false;
-        break;
-      case JSOP_MUL:
-        if (!MulValues(cx, &lhsCopy, &rhsCopy, ret))
-            return false;
-        break;
-      case JSOP_DIV:
-        if (!DivValues(cx, &lhsCopy, &rhsCopy, ret))
-            return false;
-        break;
-      case JSOP_MOD:
-        if (!ModValues(cx, &lhsCopy, &rhsCopy, ret))
-            return false;
-        break;
-      case JSOP_POW:
-        if (!PowValues(cx, &lhsCopy, &rhsCopy, ret))
-            return false;
-        break;
-      case JSOP_BITOR: {
-        int32_t result;
-        if (!BitOr(cx, lhs, rhs, &result))
-            return false;
-        ret.setInt32(result);
-        break;
-      }
-      case JSOP_BITXOR: {
-        int32_t result;
-        if (!BitXor(cx, lhs, rhs, &result))
-            return false;
-        ret.setInt32(result);
-        break;
-      }
-      case JSOP_BITAND: {
-        int32_t result;
-        if (!BitAnd(cx, lhs, rhs, &result))
-            return false;
-        ret.setInt32(result);
-        break;
-      }
-      case JSOP_LSH: {
-        int32_t result;
-        if (!BitLsh(cx, lhs, rhs, &result))
-            return false;
-        ret.setInt32(result);
-        break;
-      }
-      case JSOP_RSH: {
-        int32_t result;
-        if (!BitRsh(cx, lhs, rhs, &result))
-            return false;
-        ret.setInt32(result);
-        break;
-      }
-      case JSOP_URSH: {
-        if (!UrshOperation(cx, lhs, rhs, ret))
-            return false;
-        break;
-      }
-      default:
-        MOZ_CRASH("Unhandled baseline arith op");
-    }
-
-    // Check if debug mode toggling made the stub invalid.
-    if (stub.invalid())
-        return true;
-
-    // Try to use a CacheIR stub first. If that succeeds, then we're done. Otherwise, we
-    // need to try to attach a shared stub.
-    if (engine == ICStubCompiler::Engine::Baseline && !JitOptions.disableCacheIRBinaryArith) {
-        if (DoCacheIRBinaryArithFallback(cx, (BaselineFrame*)payload, stub_, lhs, rhs, ret, stub))
-            return true;
-    }
-
-    if (ret.isDouble())
-        stub->setSawDoubleResult();
-
-    // Check to see if a new stub should be generated.
-    if (stub->numOptimizedStubs() >= ICBinaryArith_Fallback::MAX_OPTIMIZED_STUBS) {
-        stub->noteUnoptimizableOperands();
-        return true;
-    }
-
-    // Handle string concat.
-    if (op == JSOP_ADD) {
-        if (lhs.isString() && rhs.isString()) {
-            JitSpew(JitSpew_BaselineIC, "  Generating %s(String, String) stub", CodeName[op]);
-            MOZ_ASSERT(ret.isString());
-            ICBinaryArith_StringConcat::Compiler compiler(cx, engine);
-            ICStub* strcatStub = compiler.getStub(compiler.getStubSpace(info.outerScript(cx)));
-            if (!strcatStub)
-                return false;
-            stub->addNewStub(strcatStub);
-            return true;
-        }
-
-        if ((lhs.isString() && rhs.isObject()) || (lhs.isObject() && rhs.isString())) {
-            JitSpew(JitSpew_BaselineIC, "  Generating %s(%s, %s) stub", CodeName[op],
-                    lhs.isString() ? "String" : "Object",
-                    lhs.isString() ? "Object" : "String");
-            MOZ_ASSERT(ret.isString());
-            ICBinaryArith_StringObjectConcat::Compiler compiler(cx, engine, lhs.isString());
-            ICStub* strcatStub = compiler.getStub(compiler.getStubSpace(info.outerScript(cx)));
-            if (!strcatStub)
-                return false;
-            stub->addNewStub(strcatStub);
-            return true;
-        }
-    }
-
-    if (((lhs.isBoolean() && (rhs.isBoolean() || rhs.isInt32())) ||
-         (rhs.isBoolean() && (lhs.isBoolean() || lhs.isInt32()))) &&
-        (op == JSOP_ADD || op == JSOP_SUB || op == JSOP_BITOR || op == JSOP_BITAND ||
-         op == JSOP_BITXOR))
-    {
-        JitSpew(JitSpew_BaselineIC, "  Generating %s(%s, %s) stub", CodeName[op],
-                lhs.isBoolean() ? "Boolean" : "Int32", rhs.isBoolean() ? "Boolean" : "Int32");
-        ICBinaryArith_BooleanWithInt32::Compiler compiler(cx, op, engine,
-                                                          lhs.isBoolean(), rhs.isBoolean());
-        ICStub* arithStub = compiler.getStub(compiler.getStubSpace(info.outerScript(cx)));
-        if (!arithStub)
-            return false;
-        stub->addNewStub(arithStub);
-        return true;
-    }
-
-    // Handle only int32 or double.
-    if (!lhs.isNumber() || !rhs.isNumber()) {
-        stub->noteUnoptimizableOperands();
-        return true;
-    }
-
-    MOZ_ASSERT(ret.isNumber());
-
-    if (lhs.isDouble() || rhs.isDouble() || ret.isDouble()) {
-        if (!cx->runtime()->jitSupportsFloatingPoint)
-            return true;
-
-        switch (op) {
-          case JSOP_ADD:
-          case JSOP_SUB:
-          case JSOP_MUL:
-          case JSOP_DIV:
-          case JSOP_MOD: {
-            // Unlink int32 stubs, it's faster to always use the double stub.
-            stub->unlinkStubsWithKind(cx, ICStub::BinaryArith_Int32);
-            JitSpew(JitSpew_BaselineIC, "  Generating %s(Double, Double) stub", CodeName[op]);
-
-            ICBinaryArith_Double::Compiler compiler(cx, op, engine);
-            ICStub* doubleStub = compiler.getStub(compiler.getStubSpace(info.outerScript(cx)));
-            if (!doubleStub)
-                return false;
-            stub->addNewStub(doubleStub);
-            return true;
-          }
-          default:
-            break;
-        }
-    }
-
-    if (lhs.isInt32() && rhs.isInt32() && op != JSOP_POW) {
-        bool allowDouble = ret.isDouble();
-        if (allowDouble)
-            stub->unlinkStubsWithKind(cx, ICStub::BinaryArith_Int32);
-        JitSpew(JitSpew_BaselineIC, "  Generating %s(Int32, Int32%s) stub", CodeName[op],
-                allowDouble ? " => Double" : "");
-        ICBinaryArith_Int32::Compiler compilerInt32(cx, op, engine, allowDouble);
-        ICStub* int32Stub = compilerInt32.getStub(compilerInt32.getStubSpace(info.outerScript(cx)));
-        if (!int32Stub)
-            return false;
-        stub->addNewStub(int32Stub);
-        return true;
-    }
-
-    // Handle Double <BITOP> Int32 or Int32 <BITOP> Double case.
-    if (((lhs.isDouble() && rhs.isInt32()) || (lhs.isInt32() && rhs.isDouble())) &&
-        ret.isInt32())
-    {
-        switch(op) {
-          case JSOP_BITOR:
-          case JSOP_BITXOR:
-          case JSOP_BITAND: {
-            JitSpew(JitSpew_BaselineIC, "  Generating %s(%s, %s) stub", CodeName[op],
-                        lhs.isDouble() ? "Double" : "Int32",
-                        lhs.isDouble() ? "Int32" : "Double");
-            ICBinaryArith_DoubleWithInt32::Compiler compiler(cx, op, engine, lhs.isDouble());
-            ICStub* optStub = compiler.getStub(compiler.getStubSpace(info.outerScript(cx)));
-            if (!optStub)
-                return false;
-            stub->addNewStub(optStub);
-            return true;
-          }
-          default:
-            break;
-        }
-    }
-
-    stub->noteUnoptimizableOperands();
-    return true;
-}
-
-typedef bool (*DoBinaryArithFallbackFn)(JSContext*, void*, ICBinaryArith_Fallback*,
-                                        HandleValue, HandleValue, MutableHandleValue);
-static const VMFunction DoBinaryArithFallbackInfo =
-    FunctionInfo<DoBinaryArithFallbackFn>(DoBinaryArithFallback, "DoBinaryArithFallback",
-                                          TailCall, PopValues(2));
-
-bool
-ICBinaryArith_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    MOZ_ASSERT(R0 == JSReturnOperand);
-
-    // Restore the tail call register.
-    EmitRestoreTailCallReg(masm);
-
-    // Ensure stack is fully synced for the expression decompiler.
-    masm.pushValue(R0);
-    masm.pushValue(R1);
-
-    // Push arguments.
-    masm.pushValue(R1);
-    masm.pushValue(R0);
-    masm.push(ICStubReg);
-    pushStubPayload(masm, R0.scratchReg());
-
-    return tailCallVM(DoBinaryArithFallbackInfo, masm);
-}
-
-static bool
-DoConcatStrings(JSContext* cx, HandleString lhs, HandleString rhs, MutableHandleValue res)
-{
-    JSString* result = ConcatStrings<CanGC>(cx, lhs, rhs);
-    if (!result)
-        return false;
-
-    res.setString(result);
-    return true;
-}
-
-typedef bool (*DoConcatStringsFn)(JSContext*, HandleString, HandleString, MutableHandleValue);
-static const VMFunction DoConcatStringsInfo =
-    FunctionInfo<DoConcatStringsFn>(DoConcatStrings, "DoConcatStrings", TailCall);
-
-bool
-ICBinaryArith_StringConcat::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    Label failure;
-    masm.branchTestString(Assembler::NotEqual, R0, &failure);
-    masm.branchTestString(Assembler::NotEqual, R1, &failure);
-
-    // Restore the tail call register.
-    EmitRestoreTailCallReg(masm);
-
-    masm.unboxString(R0, R0.scratchReg());
-    masm.unboxString(R1, R1.scratchReg());
-
-    masm.push(R1.scratchReg());
-    masm.push(R0.scratchReg());
-    if (!tailCallVM(DoConcatStringsInfo, masm))
-        return false;
-
-    // Failure case - jump to next stub
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-    return true;
-}
-
-typedef bool (*DoConcatStringObjectFn)(JSContext*, HandleValue, HandleValue,
-                                       MutableHandleValue);
-static const VMFunction DoSharedConcatStringObjectInfo =
-    FunctionInfo<DoConcatStringObjectFn>(DoConcatStringObject, "DoConcatStringObject", TailCall,
-                                         PopValues(2));
-
-bool
-ICBinaryArith_StringObjectConcat::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    Label failure;
-    if (lhsIsString_) {
-        masm.branchTestString(Assembler::NotEqual, R0, &failure);
-        masm.branchTestObject(Assembler::NotEqual, R1, &failure);
-    } else {
-        masm.branchTestObject(Assembler::NotEqual, R0, &failure);
-        masm.branchTestString(Assembler::NotEqual, R1, &failure);
-    }
-
-    // Restore the tail call register.
-    EmitRestoreTailCallReg(masm);
-
-    // Sync for the decompiler.
-    masm.pushValue(R0);
-    masm.pushValue(R1);
-
-    // Push arguments.
-    masm.pushValue(R1);
-    masm.pushValue(R0);
-
-    if (!tailCallVM(DoSharedConcatStringObjectInfo, masm))
-        return false;
-
-    // Failure case - jump to next stub
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-    return true;
-}
-
-bool
-ICBinaryArith_Double::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    Label failure;
-    masm.ensureDouble(R0, FloatReg0, &failure);
-    masm.ensureDouble(R1, FloatReg1, &failure);
-
-    switch (op) {
-      case JSOP_ADD:
-        masm.addDouble(FloatReg1, FloatReg0);
-        break;
-      case JSOP_SUB:
-        masm.subDouble(FloatReg1, FloatReg0);
-        break;
-      case JSOP_MUL:
-        masm.mulDouble(FloatReg1, FloatReg0);
-        break;
-      case JSOP_DIV:
-        masm.divDouble(FloatReg1, FloatReg0);
-        break;
-      case JSOP_MOD:
-        masm.setupUnalignedABICall(R0.scratchReg());
-        masm.passABIArg(FloatReg0, MoveOp::DOUBLE);
-        masm.passABIArg(FloatReg1, MoveOp::DOUBLE);
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, NumberMod), MoveOp::DOUBLE);
-        MOZ_ASSERT(ReturnDoubleReg == FloatReg0);
-        break;
-      default:
-        MOZ_CRASH("Unexpected op");
-    }
-
-    masm.boxDouble(FloatReg0, R0, FloatReg0);
-    EmitReturnFromIC(masm);
-
-    // Failure case - jump to next stub
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-    return true;
-}
-
-bool
-ICBinaryArith_BooleanWithInt32::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    Label failure;
-    if (lhsIsBool_)
-        masm.branchTestBoolean(Assembler::NotEqual, R0, &failure);
-    else
-        masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
-
-    if (rhsIsBool_)
-        masm.branchTestBoolean(Assembler::NotEqual, R1, &failure);
-    else
-        masm.branchTestInt32(Assembler::NotEqual, R1, &failure);
-
-    Register lhsReg = lhsIsBool_ ? masm.extractBoolean(R0, ExtractTemp0)
-                                 : masm.extractInt32(R0, ExtractTemp0);
-    Register rhsReg = rhsIsBool_ ? masm.extractBoolean(R1, ExtractTemp1)
-                                 : masm.extractInt32(R1, ExtractTemp1);
-
-    MOZ_ASSERT(op_ == JSOP_ADD || op_ == JSOP_SUB ||
-               op_ == JSOP_BITOR || op_ == JSOP_BITXOR || op_ == JSOP_BITAND);
-
-    switch(op_) {
-      case JSOP_ADD: {
-        Label fixOverflow;
-
-        masm.branchAdd32(Assembler::Overflow, rhsReg, lhsReg, &fixOverflow);
-        masm.tagValue(JSVAL_TYPE_INT32, lhsReg, R0);
-        EmitReturnFromIC(masm);
-
-        masm.bind(&fixOverflow);
-        masm.sub32(rhsReg, lhsReg);
-        // Proceed to failure below.
-        break;
-      }
-      case JSOP_SUB: {
-        Label fixOverflow;
-
-        masm.branchSub32(Assembler::Overflow, rhsReg, lhsReg, &fixOverflow);
-        masm.tagValue(JSVAL_TYPE_INT32, lhsReg, R0);
-        EmitReturnFromIC(masm);
-
-        masm.bind(&fixOverflow);
-        masm.add32(rhsReg, lhsReg);
-        // Proceed to failure below.
-        break;
-      }
-      case JSOP_BITOR: {
-        masm.or32(rhsReg, lhsReg);
-        masm.tagValue(JSVAL_TYPE_INT32, lhsReg, R0);
-        EmitReturnFromIC(masm);
-        break;
-      }
-      case JSOP_BITXOR: {
-        masm.xor32(rhsReg, lhsReg);
-        masm.tagValue(JSVAL_TYPE_INT32, lhsReg, R0);
-        EmitReturnFromIC(masm);
-        break;
-      }
-      case JSOP_BITAND: {
-        masm.and32(rhsReg, lhsReg);
-        masm.tagValue(JSVAL_TYPE_INT32, lhsReg, R0);
-        EmitReturnFromIC(masm);
-        break;
-      }
-      default:
-       MOZ_CRASH("Unhandled op for BinaryArith_BooleanWithInt32.");
-    }
-
-    // Failure case - jump to next stub
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-    return true;
-}
-
-bool
-ICBinaryArith_DoubleWithInt32::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    MOZ_ASSERT(op == JSOP_BITOR || op == JSOP_BITAND || op == JSOP_BITXOR);
-
-    Label failure;
-    Register intReg;
-    Register scratchReg;
-    if (lhsIsDouble_) {
-        masm.branchTestDouble(Assembler::NotEqual, R0, &failure);
-        masm.branchTestInt32(Assembler::NotEqual, R1, &failure);
-        intReg = masm.extractInt32(R1, ExtractTemp0);
-        masm.unboxDouble(R0, FloatReg0);
-        scratchReg = R0.scratchReg();
-    } else {
-        masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
-        masm.branchTestDouble(Assembler::NotEqual, R1, &failure);
-        intReg = masm.extractInt32(R0, ExtractTemp0);
-        masm.unboxDouble(R1, FloatReg0);
-        scratchReg = R1.scratchReg();
-    }
-
-    // Truncate the double to an int32.
-    {
-        Label doneTruncate;
-        Label truncateABICall;
-        masm.branchTruncateDoubleMaybeModUint32(FloatReg0, scratchReg, &truncateABICall);
-        masm.jump(&doneTruncate);
-
-        masm.bind(&truncateABICall);
-        masm.push(intReg);
-        masm.setupUnalignedABICall(scratchReg);
-        masm.passABIArg(FloatReg0, MoveOp::DOUBLE);
-        masm.callWithABI(mozilla::BitwiseCast<void*, int32_t(*)(double)>(JS::ToInt32),
-                         MoveOp::GENERAL, CheckUnsafeCallWithABI::DontCheckOther);
-        masm.storeCallInt32Result(scratchReg);
-        masm.pop(intReg);
-
-        masm.bind(&doneTruncate);
-    }
-
-    Register intReg2 = scratchReg;
-    // All handled ops commute, so no need to worry about ordering.
-    switch(op) {
-      case JSOP_BITOR:
-        masm.or32(intReg, intReg2);
-        break;
-      case JSOP_BITXOR:
-        masm.xor32(intReg, intReg2);
-        break;
-      case JSOP_BITAND:
-        masm.and32(intReg, intReg2);
-        break;
-      default:
-       MOZ_CRASH("Unhandled op for BinaryArith_DoubleWithInt32.");
-    }
-    masm.tagValue(JSVAL_TYPE_INT32, intReg2, R0);
-    EmitReturnFromIC(masm);
-
-    // Failure case - jump to next stub
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-    return true;
-}
-
-//
 // Compare_Fallback
 //
 
 static bool
 DoCompareFallback(JSContext* cx, void* payload, ICCompare_Fallback* stub_, HandleValue lhs,
                   HandleValue rhs, MutableHandleValue ret)
 {
     SharedStubInfo info(cx, payload, stub_->icEntry());
--- a/js/src/jit/SharedIC.h
+++ b/js/src/jit/SharedIC.h
@@ -1636,290 +1636,16 @@ class ICTypeMonitor_AnyValue : public IC
         { }
 
         ICTypeMonitor_AnyValue* getStub(ICStubSpace* space) override {
             return newStub<ICTypeMonitor_AnyValue>(space, getStubCode());
         }
     };
 };
 
-// BinaryArith
-//      JSOP_ADD, JSOP_SUB, JSOP_MUL, JOP_DIV, JSOP_MOD
-//      JSOP_BITAND, JSOP_BITXOR, JSOP_BITOR
-//      JSOP_LSH, JSOP_RSH, JSOP_URSH
-
-class ICBinaryArith_Fallback : public ICFallbackStub
-{
-    friend class ICStubSpace;
-
-    explicit ICBinaryArith_Fallback(JitCode* stubCode)
-      : ICFallbackStub(BinaryArith_Fallback, stubCode)
-    {
-        extra_ = 0;
-    }
-
-    static const uint16_t SAW_DOUBLE_RESULT_BIT = 0x1;
-    static const uint16_t UNOPTIMIZABLE_OPERANDS_BIT = 0x2;
-
-  public:
-    static const uint32_t MAX_OPTIMIZED_STUBS = 8;
-
-    bool sawDoubleResult() const {
-        return extra_ & SAW_DOUBLE_RESULT_BIT;
-    }
-    void setSawDoubleResult() {
-        extra_ |= SAW_DOUBLE_RESULT_BIT;
-    }
-    bool hadUnoptimizableOperands() const {
-        return extra_ & UNOPTIMIZABLE_OPERANDS_BIT;
-    }
-    void noteUnoptimizableOperands() {
-        extra_ |= UNOPTIMIZABLE_OPERANDS_BIT;
-    }
-
-    // Compiler for this stub kind.
-    class Compiler : public ICStubCompiler {
-      protected:
-        MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
-
-      public:
-        explicit Compiler(JSContext* cx, Engine engine)
-          : ICStubCompiler(cx, ICStub::BinaryArith_Fallback, engine) {}
-
-        ICStub* getStub(ICStubSpace* space) override {
-            return newStub<ICBinaryArith_Fallback>(space, getStubCode());
-        }
-    };
-};
-
-class ICBinaryArith_Int32 : public ICStub
-{
-    friend class ICStubSpace;
-
-    ICBinaryArith_Int32(JitCode* stubCode, bool allowDouble)
-      : ICStub(BinaryArith_Int32, stubCode)
-    {
-        extra_ = allowDouble;
-    }
-
-  public:
-    bool allowDouble() const {
-        return extra_;
-    }
-
-    // Compiler for this stub kind.
-    class Compiler : public ICStubCompiler {
-      protected:
-        JSOp op_;
-        bool allowDouble_;
-
-        MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
-
-        // Stub keys shift-stubs need to encode the kind, the JSOp and if we allow doubles.
-        virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
-                  (static_cast<int32_t>(op_) << 17) |
-                  (static_cast<int32_t>(allowDouble_) << 25);
-        }
-
-      public:
-        Compiler(JSContext* cx, JSOp op, Engine engine, bool allowDouble)
-          : ICStubCompiler(cx, ICStub::BinaryArith_Int32, engine),
-            op_(op), allowDouble_(allowDouble) {}
-
-        ICStub* getStub(ICStubSpace* space) override {
-            return newStub<ICBinaryArith_Int32>(space, getStubCode(), allowDouble_);
-        }
-    };
-};
-
-class ICBinaryArith_StringConcat : public ICStub
-{
-    friend class ICStubSpace;
-
-    explicit ICBinaryArith_StringConcat(JitCode* stubCode)
-      : ICStub(BinaryArith_StringConcat, stubCode)
-    {}
-
-  public:
-    class Compiler : public ICStubCompiler {
-      protected:
-        MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
-
-      public:
-        explicit Compiler(JSContext* cx, Engine engine)
-          : ICStubCompiler(cx, ICStub::BinaryArith_StringConcat, engine)
-        {}
-
-        ICStub* getStub(ICStubSpace* space) override {
-            return newStub<ICBinaryArith_StringConcat>(space, getStubCode());
-        }
-    };
-};
-
-class ICBinaryArith_StringObjectConcat : public ICStub
-{
-    friend class ICStubSpace;
-
-    ICBinaryArith_StringObjectConcat(JitCode* stubCode, bool lhsIsString)
-      : ICStub(BinaryArith_StringObjectConcat, stubCode)
-    {
-        extra_ = lhsIsString;
-    }
-
-  public:
-    bool lhsIsString() const {
-        return extra_;
-    }
-
-    class Compiler : public ICStubCompiler {
-      protected:
-        bool lhsIsString_;
-        MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
-
-        virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
-                  (static_cast<int32_t>(lhsIsString_) << 17);
-        }
-
-      public:
-        Compiler(JSContext* cx, Engine engine, bool lhsIsString)
-          : ICStubCompiler(cx, ICStub::BinaryArith_StringObjectConcat, engine),
-            lhsIsString_(lhsIsString)
-        {}
-
-        ICStub* getStub(ICStubSpace* space) override {
-            return newStub<ICBinaryArith_StringObjectConcat>(space, getStubCode(),
-                                                                 lhsIsString_);
-        }
-    };
-};
-
-class ICBinaryArith_Double : public ICStub
-{
-    friend class ICStubSpace;
-
-    explicit ICBinaryArith_Double(JitCode* stubCode)
-      : ICStub(BinaryArith_Double, stubCode)
-    {}
-
-  public:
-    class Compiler : public ICMultiStubCompiler {
-      protected:
-        MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
-
-      public:
-        Compiler(JSContext* cx, JSOp op, Engine engine)
-          : ICMultiStubCompiler(cx, ICStub::BinaryArith_Double, op, engine)
-        {}
-
-        ICStub* getStub(ICStubSpace* space) override {
-            return newStub<ICBinaryArith_Double>(space, getStubCode());
-        }
-    };
-};
-
-class ICBinaryArith_BooleanWithInt32 : public ICStub
-{
-    friend class ICStubSpace;
-
-    ICBinaryArith_BooleanWithInt32(JitCode* stubCode, bool lhsIsBool, bool rhsIsBool)
-      : ICStub(BinaryArith_BooleanWithInt32, stubCode)
-    {
-        MOZ_ASSERT(lhsIsBool || rhsIsBool);
-        extra_ = 0;
-        if (lhsIsBool)
-            extra_ |= 1;
-        if (rhsIsBool)
-            extra_ |= 2;
-    }
-
-  public:
-    bool lhsIsBoolean() const {
-        return extra_ & 1;
-    }
-
-    bool rhsIsBoolean() const {
-        return extra_ & 2;
-    }
-
-    class Compiler : public ICStubCompiler {
-      protected:
-        JSOp op_;
-        bool lhsIsBool_;
-        bool rhsIsBool_;
-        MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
-
-        virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
-                  (static_cast<int32_t>(op_) << 17) |
-                  (static_cast<int32_t>(lhsIsBool_) << 25) |
-                  (static_cast<int32_t>(rhsIsBool_) << 26);
-        }
-
-      public:
-        Compiler(JSContext* cx, JSOp op, Engine engine, bool lhsIsBool, bool rhsIsBool)
-          : ICStubCompiler(cx, ICStub::BinaryArith_BooleanWithInt32, engine),
-            op_(op), lhsIsBool_(lhsIsBool), rhsIsBool_(rhsIsBool)
-        {
-            MOZ_ASSERT(op_ == JSOP_ADD || op_ == JSOP_SUB || op_ == JSOP_BITOR ||
-                       op_ == JSOP_BITAND || op_ == JSOP_BITXOR);
-            MOZ_ASSERT(lhsIsBool_ || rhsIsBool_);
-        }
-
-        ICStub* getStub(ICStubSpace* space) override {
-            return newStub<ICBinaryArith_BooleanWithInt32>(space, getStubCode(),
-                                                               lhsIsBool_, rhsIsBool_);
-        }
-    };
-};
-
-class ICBinaryArith_DoubleWithInt32 : public ICStub
-{
-    friend class ICStubSpace;
-
-    ICBinaryArith_DoubleWithInt32(JitCode* stubCode, bool lhsIsDouble)
-      : ICStub(BinaryArith_DoubleWithInt32, stubCode)
-    {
-        extra_ = lhsIsDouble;
-    }
-
-  public:
-    bool lhsIsDouble() const {
-        return extra_;
-    }
-
-    class Compiler : public ICMultiStubCompiler {
-      protected:
-        bool lhsIsDouble_;
-        MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
-
-        virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
-                  (static_cast<int32_t>(op) << 17) |
-                  (static_cast<int32_t>(lhsIsDouble_) << 25);
-        }
-
-      public:
-        Compiler(JSContext* cx, JSOp op, Engine engine, bool lhsIsDouble)
-          : ICMultiStubCompiler(cx, ICStub::BinaryArith_DoubleWithInt32, op, engine),
-            lhsIsDouble_(lhsIsDouble)
-        {}
-
-        ICStub* getStub(ICStubSpace* space) override {
-            return newStub<ICBinaryArith_DoubleWithInt32>(space, getStubCode(),
-                                                              lhsIsDouble_);
-        }
-    };
-};
-
 // Compare
 //      JSOP_LT
 //      JSOP_LE
 //      JSOP_GT
 //      JSOP_GE
 //      JSOP_EQ
 //      JSOP_NE
 //      JSOP_STRICTEQ
--- a/js/src/jit/SharedICList.h
+++ b/js/src/jit/SharedICList.h
@@ -8,22 +8,16 @@
 #define jit_SharedICList_h
 
 namespace js {
 namespace jit {
 
 // List of IC stub kinds that can run in Baseline and in IonMonkey
 #define IC_SHARED_STUB_KIND_LIST(_)              \
     _(BinaryArith_Fallback)                      \
-    _(BinaryArith_Int32)                         \
-    _(BinaryArith_Double)                        \
-    _(BinaryArith_StringConcat)                  \
-    _(BinaryArith_StringObjectConcat)            \
-    _(BinaryArith_BooleanWithInt32)              \
-    _(BinaryArith_DoubleWithInt32)               \
                                                  \
     _(Compare_Fallback)                          \
     _(Compare_Int32)                             \
     _(Compare_Double)                            \
     _(Compare_NumberWithUndefined)               \
     _(Compare_String)                            \
     _(Compare_Symbol)                            \
     _(Compare_Boolean)                           \
deleted file mode 100644
--- a/js/src/jit/arm/SharedIC-arm.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sts=4 et sw=4 tw=99:
- * 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 "jit/BaselineCompiler.h"
-#include "jit/BaselineIC.h"
-#include "jit/BaselineJIT.h"
-#include "jit/Linker.h"
-#include "jit/SharedICHelpers.h"
-
-#include "jit/MacroAssembler-inl.h"
-
-using namespace js;
-using namespace js::jit;
-
-namespace js {
-namespace jit {
-
-// ICBinaryArith_Int32
-
-extern "C" {
-    extern MOZ_EXPORT int64_t __aeabi_idivmod(int,int);
-}
-
-bool
-ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    // Guard that R0 is an integer and R1 is an integer.
-    Label failure;
-    masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
-    masm.branchTestInt32(Assembler::NotEqual, R1, &failure);
-
-    // Add R0 and R1. Don't need to explicitly unbox, just use R2's payloadReg.
-    Register scratchReg = R2.payloadReg();
-
-    // DIV and MOD need an extra non-volatile ValueOperand to hold R0.
-    AllocatableGeneralRegisterSet savedRegs(availableGeneralRegs(2));
-    savedRegs.set() = GeneralRegisterSet::Intersect(GeneralRegisterSet::NonVolatile(), savedRegs.set());
-    ValueOperand savedValue = savedRegs.takeAnyValue();
-
-    Label maybeNegZero, revertRegister;
-    switch(op_) {
-      case JSOP_ADD:
-        masm.ma_add(R0.payloadReg(), R1.payloadReg(), scratchReg, SetCC);
-
-        // Just jump to failure on overflow. R0 and R1 are preserved, so we can
-        // just jump to the next stub.
-        masm.j(Assembler::Overflow, &failure);
-
-        // Box the result and return. We know R0.typeReg() already contains the
-        // integer tag, so we just need to move the result value into place.
-        masm.mov(scratchReg, R0.payloadReg());
-        break;
-      case JSOP_SUB:
-        masm.ma_sub(R0.payloadReg(), R1.payloadReg(), scratchReg, SetCC);
-        masm.j(Assembler::Overflow, &failure);
-        masm.mov(scratchReg, R0.payloadReg());
-        break;
-      case JSOP_MUL: {
-        ScratchRegisterScope scratch(masm);
-        Assembler::Condition cond = masm.ma_check_mul(R0.payloadReg(), R1.payloadReg(), scratchReg,
-                                                      scratch, Assembler::Overflow);
-        masm.j(cond, &failure);
-
-        masm.as_cmp(scratchReg, Imm8(0));
-        masm.j(Assembler::Equal, &maybeNegZero);
-
-        masm.mov(scratchReg, R0.payloadReg());
-        break;
-      }
-      case JSOP_DIV:
-      case JSOP_MOD: {
-        // Check for INT_MIN / -1, it results in a double.
-        {
-            ScratchRegisterScope scratch(masm);
-            masm.ma_cmp(R0.payloadReg(), Imm32(INT_MIN), scratch);
-            masm.ma_cmp(R1.payloadReg(), Imm32(-1), scratch, Assembler::Equal);
-            masm.j(Assembler::Equal, &failure);
-        }
-
-        // Check for both division by zero and 0 / X with X < 0 (results in -0).
-        masm.as_cmp(R1.payloadReg(), Imm8(0));
-        masm.as_cmp(R0.payloadReg(), Imm8(0), Assembler::LessThan);
-        masm.j(Assembler::Equal, &failure);
-
-        // The call will preserve registers r4-r11. Save R0 and the link
-        // register.
-        MOZ_ASSERT(R1 == ValueOperand(r5, r4));
-        MOZ_ASSERT(R0 == ValueOperand(r3, r2));
-        masm.moveValue(R0, savedValue);
-
-        masm.setupAlignedABICall();
-        masm.passABIArg(R0.payloadReg());
-        masm.passABIArg(R1.payloadReg());
-        masm.callWithABI(JS_FUNC_TO_DATA_PTR(void*, __aeabi_idivmod), MoveOp::GENERAL,
-                         CheckUnsafeCallWithABI::DontCheckOther);
-
-        // idivmod returns the quotient in r0, and the remainder in r1.
-        if (op_ == JSOP_DIV) {
-            // Result is a double if the remainder != 0.
-            masm.branch32(Assembler::NotEqual, r1, Imm32(0), &revertRegister);
-            masm.tagValue(JSVAL_TYPE_INT32, r0, R0);
-        } else {
-            // If X % Y == 0 and X < 0, the result is -0.
-            Label done;
-            masm.branch32(Assembler::NotEqual, r1, Imm32(0), &done);
-            masm.branch32(Assembler::LessThan, savedValue.payloadReg(), Imm32(0), &revertRegister);
-            masm.bind(&done);
-            masm.tagValue(JSVAL_TYPE_INT32, r1, R0);
-        }
-        break;
-      }
-      case JSOP_BITOR:
-        masm.ma_orr(R1.payloadReg(), R0.payloadReg(), R0.payloadReg());
-        break;
-      case JSOP_BITXOR:
-        masm.ma_eor(R1.payloadReg(), R0.payloadReg(), R0.payloadReg());
-        break;
-      case JSOP_BITAND:
-        masm.ma_and(R1.payloadReg(), R0.payloadReg(), R0.payloadReg());
-        break;
-      case JSOP_LSH:
-        // ARM will happily try to shift by more than 0x1f.
-        masm.as_and(R1.payloadReg(), R1.payloadReg(), Imm8(0x1F));
-        masm.ma_lsl(R1.payloadReg(), R0.payloadReg(), R0.payloadReg());
-        break;
-      case JSOP_RSH:
-        masm.as_and(R1.payloadReg(), R1.payloadReg(), Imm8(0x1F));
-        masm.ma_asr(R1.payloadReg(), R0.payloadReg(), R0.payloadReg());
-        break;
-      case JSOP_URSH:
-        masm.as_and(scratchReg, R1.payloadReg(), Imm8(0x1F));
-        masm.ma_lsr(scratchReg, R0.payloadReg(), scratchReg);
-        masm.as_cmp(scratchReg, Imm8(0));
-        if (allowDouble_) {
-            Label toUint;
-            masm.j(Assembler::LessThan, &toUint);
-
-            // Move result and box for return.
-            masm.mov(scratchReg, R0.payloadReg());
-            EmitReturnFromIC(masm);
-
-            masm.bind(&toUint);
-            ScratchDoubleScope scratchDouble(masm);
-            masm.convertUInt32ToDouble(scratchReg, scratchDouble);
-            masm.boxDouble(scratchDouble, R0, scratchDouble);
-        } else {
-            masm.j(Assembler::LessThan, &failure);
-            // Move result for return.
-            masm.mov(scratchReg, R0.payloadReg());
-        }
-        break;
-      default:
-        MOZ_CRASH("Unhandled op for BinaryArith_Int32.");
-    }
-
-    EmitReturnFromIC(masm);
-
-    switch (op_) {
-      case JSOP_MUL:
-        masm.bind(&maybeNegZero);
-
-        // Result is -0 if exactly one of lhs or rhs is negative.
-        masm.ma_cmn(R0.payloadReg(), R1.payloadReg());
-        masm.j(Assembler::Signed, &failure);
-
-        // Result is +0.
-        masm.ma_mov(Imm32(0), R0.payloadReg());
-        EmitReturnFromIC(masm);
-        break;
-      case JSOP_DIV:
-      case JSOP_MOD:
-        masm.bind(&revertRegister);
-        masm.moveValue(savedValue, R0);
-        break;
-      default:
-        break;
-    }
-
-    // Failure case - jump to next stub.
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-
-    return true;
-}
-
-} // namespace jit
-} // namespace js
deleted file mode 100644
--- a/js/src/jit/arm64/SharedIC-arm64.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sts=4 et sw=4 tw=99:
- * 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 "jit/SharedIC.h"
-#include "jit/SharedICHelpers.h"
-
-#ifdef JS_SIMULATOR_ARM64
-#include "jit/arm64/Assembler-arm64.h"
-#include "jit/arm64/BaselineCompiler-arm64.h"
-#include "jit/arm64/vixl/Debugger-vixl.h"
-#endif
-
-#include "jit/arm64/MacroAssembler-arm64-inl.h"
-
-using namespace js;
-using namespace js::jit;
-
-namespace js {
-namespace jit {
-
-// ICBinaryArith_Int32
-
-bool
-ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    // Guard that R0 is an integer and R1 is an integer.
-    Label failure;
-    masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
-    masm.branchTestInt32(Assembler::NotEqual, R1, &failure);
-
-    // Add R0 and R1. Don't need to explicitly unbox, just use R2.
-    Register Rscratch = R2_;
-    ARMRegister Wscratch = ARMRegister(Rscratch, 32);
-#ifdef MERGE
-    // DIV and MOD need an extra non-volatile ValueOperand to hold R0.
-    AllocatableGeneralRegisterSet savedRegs(availableGeneralRegs(2));
-    savedRegs.set() = GeneralRegisterSet::Intersect(GeneralRegisterSet::NonVolatile(), savedRegs);
-#endif
-    // get some more ARM-y names for the registers
-    ARMRegister W0(R0_, 32);
-    ARMRegister X0(R0_, 64);
-    ARMRegister W1(R1_, 32);
-    ARMRegister X1(R1_, 64);
-    ARMRegister WTemp(ExtractTemp0, 32);
-    Label maybeNegZero, revertRegister;
-    switch(op_) {
-      case JSOP_ADD:
-        masm.Adds(WTemp, W0, Operand(W1));
-
-        // Just jump to failure on overflow. R0 and R1 are preserved, so we can
-        // just jump to the next stub.
-        masm.j(Assembler::Overflow, &failure);
-
-        // Box the result and return. We know R0 already contains the
-        // integer tag, so we just need to move the payload into place.
-        masm.movePayload(ExtractTemp0, R0_);
-        break;
-
-      case JSOP_SUB:
-        masm.Subs(WTemp, W0, Operand(W1));
-        masm.j(Assembler::Overflow, &failure);
-        masm.movePayload(ExtractTemp0, R0_);
-        break;
-
-      case JSOP_MUL:
-        masm.mul32(R0.valueReg(), R1.valueReg(), Rscratch, &failure, &maybeNegZero);
-        masm.movePayload(Rscratch, R0_);
-        break;
-
-      case JSOP_DIV:
-      case JSOP_MOD: {
-
-        // Check for INT_MIN / -1, it results in a double.
-        Label check2;
-        masm.Cmp(W0, Operand(INT_MIN));
-        masm.B(&check2, Assembler::NotEqual);
-        masm.Cmp(W1, Operand(-1));
-        masm.j(Assembler::Equal, &failure);
-        masm.bind(&check2);
-        Label no_fail;
-        // Check for both division by zero and 0 / X with X < 0 (results in -0).
-        masm.Cmp(W1, Operand(0));
-        // If x > 0, then it can't be bad.
-        masm.B(&no_fail, Assembler::GreaterThan);
-        // if x == 0, then ignore any comparison, and force
-        // it to fail, if x < 0 (the only other case)
-        // then do the comparison, and fail if y == 0
-        masm.Ccmp(W0, Operand(0), vixl::ZFlag, Assembler::NotEqual);
-        masm.B(&failure, Assembler::Equal);
-        masm.bind(&no_fail);
-        masm.Sdiv(Wscratch, W0, W1);
-        // Start calculating the remainder, x - (x / y) * y.
-        masm.mul(WTemp, W1, Wscratch);
-        if (op_ == JSOP_DIV) {
-            // Result is a double if the remainder != 0, which happens
-            // when (x/y)*y != x.
-            masm.branch32(Assembler::NotEqual, R0.valueReg(), ExtractTemp0, &revertRegister);
-            masm.movePayload(Rscratch, R0_);
-        } else {
-            // Calculate the actual mod. Set the condition code, so we can see if it is non-zero.
-            masm.Subs(WTemp, W0, WTemp);
-
-            // If X % Y == 0 and X < 0, the result is -0.
-            masm.Ccmp(W0, Operand(0), vixl::NoFlag, Assembler::Equal);
-            masm.branch(Assembler::LessThan, &revertRegister);
-            masm.movePayload(ExtractTemp0, R0_);
-        }
-        break;
-      }
-        // ORR, EOR, AND can trivially be coerced int
-        // working without affecting the tag of the dest..
-      case JSOP_BITOR:
-        masm.Orr(X0, X0, Operand(X1));
-        break;
-      case JSOP_BITXOR:
-        masm.Eor(X0, X0, Operand(W1, vixl::UXTW));
-        break;
-      case JSOP_BITAND:
-        masm.And(X0, X0, Operand(X1));
-        break;
-        // LSH, RSH and URSH can not.
-      case JSOP_LSH:
-        // ARM will happily try to shift by more than 0x1f.
-        masm.Lsl(Wscratch, W0, W1);
-        masm.movePayload(Rscratch, R0.valueReg());
-        break;
-      case JSOP_RSH:
-        masm.Asr(Wscratch, W0, W1);
-        masm.movePayload(Rscratch, R0.valueReg());
-        break;
-      case JSOP_URSH:
-        masm.Lsr(Wscratch, W0, W1);
-        if (allowDouble_) {
-            Label toUint;
-            // Testing for negative is equivalent to testing bit 31
-            masm.Tbnz(Wscratch, 31, &toUint);
-            // Move result and box for return.
-            masm.movePayload(Rscratch, R0_);
-            EmitReturnFromIC(masm);
-
-            masm.bind(&toUint);
-            masm.convertUInt32ToDouble(Rscratch, ScratchDoubleReg);
-            masm.boxDouble(ScratchDoubleReg, R0, ScratchDoubleReg);
-        } else {
-            // Testing for negative is equivalent to testing bit 31
-            masm.Tbnz(Wscratch, 31, &failure);
-            // Move result for return.
-            masm.movePayload(Rscratch, R0_);
-        }
-        break;
-      default:
-        MOZ_CRASH("Unhandled op for BinaryArith_Int32.");
-    }
-
-    EmitReturnFromIC(masm);
-
-    switch (op_) {
-      case JSOP_MUL:
-        masm.bind(&maybeNegZero);
-
-        // Result is -0 if exactly one of lhs or rhs is negative.
-        masm.Cmn(W0, W1);
-        masm.j(Assembler::Signed, &failure);
-
-        // Result is +0, so use the zero register.
-        masm.movePayload(rzr, R0_);
-        EmitReturnFromIC(masm);
-        break;
-      case JSOP_DIV:
-      case JSOP_MOD:
-        masm.bind(&revertRegister);
-        break;
-      default:
-        break;
-    }
-
-    // Failure case - jump to next stub.
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-
-    return true;
-}
-
-} // namespace jit
-} // namespace js
deleted file mode 100644
--- a/js/src/jit/mips32/SharedIC-mips32.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sts=4 et sw=4 tw=99:
- * 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 "jit/BaselineCompiler.h"
-#include "jit/BaselineIC.h"
-#include "jit/BaselineJIT.h"
-#include "jit/Linker.h"
-#include "jit/SharedICHelpers.h"
-#include "vm/Iteration.h"
-
-#include "builtin/Boolean-inl.h"
-
-using namespace js;
-using namespace js::jit;
-
-namespace js {
-namespace jit {
-
-// ICBinaryArith_Int32
-
-bool
-ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    // Guard that R0 is an integer and R1 is an integer.
-    Label failure;
-    masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
-    masm.branchTestInt32(Assembler::NotEqual, R1, &failure);
-
-    // Add R0 and R1. Don't need to explicitly unbox, just use R2's payloadReg.
-    Register scratchReg = R2.payloadReg();
-
-    // DIV and MOD need an extra non-volatile ValueOperand to hold R0.
-    AllocatableGeneralRegisterSet savedRegs(availableGeneralRegs(2));
-    savedRegs.set() = GeneralRegisterSet::Intersect(GeneralRegisterSet::NonVolatile(), savedRegs.set());
-
-    Label goodMul, divTest1, divTest2;
-    switch(op_) {
-      case JSOP_ADD:
-        // We know R0.typeReg() already contains the integer tag. No boxing
-        // required.
-        masm.ma_addTestOverflow(scratchReg, R0.payloadReg(), R1.payloadReg(), &failure);
-        masm.move32(scratchReg, R0.payloadReg());
-        break;
-      case JSOP_SUB:
-        masm.ma_subTestOverflow(scratchReg, R0.payloadReg(), R1.payloadReg(), &failure);
-        masm.move32(scratchReg, R0.payloadReg());
-        break;
-      case JSOP_MUL: {
-        masm.ma_mul_branch_overflow(scratchReg, R0.payloadReg(), R1.payloadReg(), &failure);
-
-        masm.ma_b(scratchReg, Imm32(0), &goodMul, Assembler::NotEqual, ShortJump);
-
-        // Result is -0 if operands have different signs.
-        masm.as_xor(t8, R0.payloadReg(), R1.payloadReg());
-        masm.ma_b(t8, Imm32(0), &failure, Assembler::LessThan, ShortJump);
-
-        masm.bind(&goodMul);
-        masm.move32(scratchReg, R0.payloadReg());
-        break;
-      }
-      case JSOP_DIV:
-      case JSOP_MOD: {
-        // Check for INT_MIN / -1, it results in a double.
-        masm.ma_b(R0.payloadReg(), Imm32(INT_MIN), &divTest1, Assembler::NotEqual, ShortJump);
-        masm.ma_b(R1.payloadReg(), Imm32(-1), &failure, Assembler::Equal, ShortJump);
-        masm.bind(&divTest1);
-
-        // Check for division by zero
-        masm.ma_b(R1.payloadReg(), Imm32(0), &failure, Assembler::Equal, ShortJump);
-
-        // Check for 0 / X with X < 0 (results in -0).
-        masm.ma_b(R0.payloadReg(), Imm32(0), &divTest2, Assembler::NotEqual, ShortJump);
-        masm.ma_b(R1.payloadReg(), Imm32(0), &failure, Assembler::LessThan, ShortJump);
-        masm.bind(&divTest2);
-
-        masm.as_div(R0.payloadReg(), R1.payloadReg());
-
-        if (op_ == JSOP_DIV) {
-            // Result is a double if the remainder != 0.
-            masm.as_mfhi(scratchReg);
-            masm.ma_b(scratchReg, Imm32(0), &failure, Assembler::NotEqual, ShortJump);
-            masm.as_mflo(scratchReg);
-            masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-        } else {
-            Label done;
-            // If X % Y == 0 and X < 0, the result is -0.
-            masm.as_mfhi(scratchReg);
-            masm.ma_b(scratchReg, Imm32(0), &done, Assembler::NotEqual, ShortJump);
-            masm.ma_b(R0.payloadReg(), Imm32(0), &failure, Assembler::LessThan, ShortJump);
-            masm.bind(&done);
-            masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-        }
-        break;
-      }
-      case JSOP_BITOR:
-        masm.as_or(R0.payloadReg() , R0.payloadReg(), R1.payloadReg());
-        break;
-      case JSOP_BITXOR:
-        masm.as_xor(R0.payloadReg() , R0.payloadReg(), R1.payloadReg());
-        break;
-      case JSOP_BITAND:
-        masm.as_and(R0.payloadReg() , R0.payloadReg(), R1.payloadReg());
-        break;
-      case JSOP_LSH:
-        // MIPS will only use 5 lowest bits in R1 as shift offset.
-        masm.ma_sll(R0.payloadReg(), R0.payloadReg(), R1.payloadReg());
-        break;
-      case JSOP_RSH:
-        masm.ma_sra(R0.payloadReg(), R0.payloadReg(), R1.payloadReg());
-        break;
-      case JSOP_URSH:
-        masm.ma_srl(scratchReg, R0.payloadReg(), R1.payloadReg());
-        if (allowDouble_) {
-            Label toUint;
-            masm.ma_b(scratchReg, Imm32(0), &toUint, Assembler::LessThan, ShortJump);
-
-            // Move result and box for return.
-            masm.move32(scratchReg, R0.payloadReg());
-            EmitReturnFromIC(masm);
-
-            masm.bind(&toUint);
-            masm.convertUInt32ToDouble(scratchReg, FloatReg1);
-            masm.boxDouble(FloatReg1, R0, ScratchDoubleReg);
-        } else {
-            masm.ma_b(scratchReg, Imm32(0), &failure, Assembler::LessThan, ShortJump);
-            // Move result for return.
-            masm.move32(scratchReg, R0.payloadReg());
-        }
-        break;
-      default:
-        MOZ_CRASH("Unhandled op for BinaryArith_Int32.");
-    }
-
-    EmitReturnFromIC(masm);
-
-    // Failure case - jump to next stub
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-
-    return true;
-}
-
-} // namespace jit
-} // namespace js
deleted file mode 100644
--- a/js/src/jit/mips64/SharedIC-mips64.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sts=4 et sw=4 tw=99:
- * 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 "jit/BaselineCompiler.h"
-#include "jit/BaselineIC.h"
-#include "jit/BaselineJIT.h"
-#include "jit/Linker.h"
-#include "jit/SharedICHelpers.h"
-#include "vm/Iteration.h"
-
-#include "builtin/Boolean-inl.h"
-
-using namespace js;
-using namespace js::jit;
-
-namespace js {
-namespace jit {
-
-// ICBinaryArith_Int32
-
-bool
-ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    // Guard that R0 is an integer and R1 is an integer.
-    Label failure;
-    masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
-    masm.branchTestInt32(Assembler::NotEqual, R1, &failure);
-
-    // Add R0 and R1. Don't need to explicitly unbox, just use R2's valueReg.
-    Register scratchReg = R2.valueReg();
-
-    Label goodMul, divTest1, divTest2;
-    switch(op_) {
-      case JSOP_ADD:
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ExtractTemp1);
-        masm.ma_addTestOverflow(scratchReg, ExtractTemp0, ExtractTemp1, &failure);
-        masm.boxValue(JSVAL_TYPE_INT32, scratchReg, R0.valueReg());
-        break;
-      case JSOP_SUB:
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ExtractTemp1);
-        masm.ma_subTestOverflow(scratchReg, ExtractTemp0, ExtractTemp1, &failure);
-        masm.boxValue(JSVAL_TYPE_INT32, scratchReg, R0.valueReg());
-        break;
-      case JSOP_MUL: {
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ExtractTemp1);
-        masm.ma_mul_branch_overflow(scratchReg, ExtractTemp0, ExtractTemp1, &failure);
-
-        masm.ma_b(scratchReg, Imm32(0), &goodMul, Assembler::NotEqual, ShortJump);
-
-        // Result is -0 if operands have different signs.
-        masm.as_xor(t8, ExtractTemp0, ExtractTemp1);
-        masm.ma_b(t8, Imm32(0), &failure, Assembler::LessThan, ShortJump);
-
-        masm.bind(&goodMul);
-        masm.boxValue(JSVAL_TYPE_INT32, scratchReg, R0.valueReg());
-        break;
-      }
-      case JSOP_DIV:
-      case JSOP_MOD: {
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ExtractTemp1);
-        // Check for INT_MIN / -1, it results in a double.
-        masm.ma_b(ExtractTemp0, Imm32(INT_MIN), &divTest1, Assembler::NotEqual, ShortJump);
-        masm.ma_b(ExtractTemp1, Imm32(-1), &failure, Assembler::Equal, ShortJump);
-        masm.bind(&divTest1);
-
-        // Check for division by zero
-        masm.ma_b(ExtractTemp1, Imm32(0), &failure, Assembler::Equal, ShortJump);
-
-        // Check for 0 / X with X < 0 (results in -0).
-        masm.ma_b(ExtractTemp0, Imm32(0), &divTest2, Assembler::NotEqual, ShortJump);
-        masm.ma_b(ExtractTemp1, Imm32(0), &failure, Assembler::LessThan, ShortJump);
-        masm.bind(&divTest2);
-
-        masm.as_div(ExtractTemp0, ExtractTemp1);
-
-        if (op_ == JSOP_DIV) {
-            // Result is a double if the remainder != 0.
-            masm.as_mfhi(scratchReg);
-            masm.ma_b(scratchReg, Imm32(0), &failure, Assembler::NotEqual, ShortJump);
-            masm.as_mflo(scratchReg);
-            masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-        } else {
-            Label done;
-            // If X % Y == 0 and X < 0, the result is -0.
-            masm.as_mfhi(scratchReg);
-            masm.ma_b(scratchReg, Imm32(0), &done, Assembler::NotEqual, ShortJump);
-            masm.ma_b(ExtractTemp0, Imm32(0), &failure, Assembler::LessThan, ShortJump);
-            masm.bind(&done);
-            masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-        }
-        break;
-      }
-      case JSOP_BITOR:
-        masm.as_or(R0.valueReg() , R0.valueReg(), R1.valueReg());
-        break;
-      case JSOP_BITXOR:
-        masm.as_xor(scratchReg, R0.valueReg(), R1.valueReg());
-        masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-        break;
-      case JSOP_BITAND:
-        masm.as_and(R0.valueReg() , R0.valueReg(), R1.valueReg());
-        break;
-      case JSOP_LSH:
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ExtractTemp1);
-        // MIPS will only use 5 lowest bits in R1 as shift offset.
-        masm.ma_sll(scratchReg, ExtractTemp0, ExtractTemp1);
-        masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-        break;
-      case JSOP_RSH:
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ExtractTemp1);
-        masm.ma_sra(scratchReg, ExtractTemp0, ExtractTemp1);
-        masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-        break;
-      case JSOP_URSH:
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ExtractTemp1);
-        masm.ma_srl(scratchReg, ExtractTemp0, ExtractTemp1);
-        if (allowDouble_) {
-            Label toUint;
-            masm.ma_b(scratchReg, Imm32(0), &toUint, Assembler::LessThan, ShortJump);
-
-            // Move result and box for return.
-            masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-            EmitReturnFromIC(masm);
-
-            masm.bind(&toUint);
-            masm.convertUInt32ToDouble(scratchReg, FloatReg1);
-            masm.boxDouble(FloatReg1, R0, ScratchDoubleReg);
-        } else {
-            masm.ma_b(scratchReg, Imm32(0), &failure, Assembler::LessThan, ShortJump);
-            // Move result for return.
-            masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-        }
-        break;
-      default:
-        MOZ_CRASH("Unhandled op for BinaryArith_Int32.");
-    }
-
-    EmitReturnFromIC(masm);
-
-    // Failure case - jump to next stub
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-
-    return true;
-}
-
-} // namespace jit
-} // namespace js
--- a/js/src/jit/none/Trampoline-none.cpp
+++ b/js/src/jit/none/Trampoline-none.cpp
@@ -39,9 +39,8 @@ BailoutFrameInfo::BailoutFrameInfo(const
 
 BailoutFrameInfo::BailoutFrameInfo(const JitActivationIterator& iter, InvalidationBailoutStack* bailout)
 {
     MOZ_CRASH();
 }
 
 bool ICCompare_Int32::Compiler::generateStubCode(MacroAssembler&) { MOZ_CRASH(); }
 bool ICCompare_Double::Compiler::generateStubCode(MacroAssembler&) { MOZ_CRASH(); }
-bool ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler&) { MOZ_CRASH(); }
deleted file mode 100644
--- a/js/src/jit/x64/SharedIC-x64.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sts=4 et sw=4 tw=99:
- * 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 "jit/BaselineIC.h"
-#include "jit/SharedICHelpers.h"
-
-#include "jit/MacroAssembler-inl.h"
-
-using namespace js;
-using namespace js::jit;
-
-namespace js {
-namespace jit {
-
-// ICBinaryArith_Int32
-
-bool
-ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    // Guard that R0 is an integer and R1 is an integer.
-    Label failure;
-    masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
-    masm.branchTestInt32(Assembler::NotEqual, R1, &failure);
-
-    // The scratch register is only used in the case of JSOP_URSH.
-    mozilla::Maybe<ScratchRegisterScope> scratch;
-
-    Label revertRegister, maybeNegZero;
-    switch(op_) {
-      case JSOP_ADD:
-        masm.unboxInt32(R0, ExtractTemp0);
-        // Just jump to failure on overflow. R0 and R1 are preserved, so we can just jump to
-        // the next stub.
-        masm.addl(R1.valueReg(), ExtractTemp0);
-        masm.j(Assembler::Overflow, &failure);
-
-        // Box the result
-        masm.boxValue(JSVAL_TYPE_INT32, ExtractTemp0, R0.valueReg());
-        break;
-      case JSOP_SUB:
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.subl(R1.valueReg(), ExtractTemp0);
-        masm.j(Assembler::Overflow, &failure);
-        masm.boxValue(JSVAL_TYPE_INT32, ExtractTemp0, R0.valueReg());
-        break;
-      case JSOP_MUL:
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.imull(R1.valueReg(), ExtractTemp0);
-        masm.j(Assembler::Overflow, &failure);
-
-        masm.branchTest32(Assembler::Zero, ExtractTemp0, ExtractTemp0, &maybeNegZero);
-
-        masm.boxValue(JSVAL_TYPE_INT32, ExtractTemp0, R0.valueReg());
-        break;
-      case JSOP_DIV:
-      {
-        MOZ_ASSERT(R2.scratchReg() == rax);
-        MOZ_ASSERT(R0.valueReg() != rdx);
-        MOZ_ASSERT(R1.valueReg() != rdx);
-        masm.unboxInt32(R0, eax);
-        masm.unboxInt32(R1, ExtractTemp0);
-
-        // Prevent division by 0.
-        masm.branchTest32(Assembler::Zero, ExtractTemp0, ExtractTemp0, &failure);
-
-        // Prevent negative 0 and -2147483648 / -1.
-        masm.branch32(Assembler::Equal, eax, Imm32(INT32_MIN), &failure);
-
-        Label notZero;
-        masm.branch32(Assembler::NotEqual, eax, Imm32(0), &notZero);
-        masm.branchTest32(Assembler::Signed, ExtractTemp0, ExtractTemp0, &failure);
-        masm.bind(&notZero);
-
-        // Sign extend eax into edx to make (edx:eax), since idiv is 64-bit.
-        masm.cdq();
-        masm.idiv(ExtractTemp0);
-
-        // A remainder implies a double result.
-        masm.branchTest32(Assembler::NonZero, edx, edx, &failure);
-
-        masm.boxValue(JSVAL_TYPE_INT32, eax, R0.valueReg());
-        break;
-      }
-      case JSOP_MOD:
-      {
-        MOZ_ASSERT(R2.scratchReg() == rax);
-        MOZ_ASSERT(R0.valueReg() != rdx);
-        MOZ_ASSERT(R1.valueReg() != rdx);
-        masm.unboxInt32(R0, eax);
-        masm.unboxInt32(R1, ExtractTemp0);
-
-        // x % 0 always results in NaN.
-        masm.branchTest32(Assembler::Zero, ExtractTemp0, ExtractTemp0, &failure);
-
-        // Prevent negative 0 and -2147483648 % -1.
-        masm.branchTest32(Assembler::Zero, eax, Imm32(0x7fffffff), &failure);
-
-        // Sign extend eax into edx to make (edx:eax), since idiv is 64-bit.
-        masm.cdq();
-        masm.idiv(ExtractTemp0);
-
-        // Fail when we would need a negative remainder.
-        Label done;
-        masm.branchTest32(Assembler::NonZero, edx, edx, &done);
-        masm.orl(ExtractTemp0, eax);
-        masm.branchTest32(Assembler::Signed, eax, eax, &failure);
-
-        masm.bind(&done);
-        masm.boxValue(JSVAL_TYPE_INT32, edx, R0.valueReg());
-        break;
-      }
-      case JSOP_BITOR:
-        // We can overide R0, because the instruction is unfailable.
-        // Because the tag bits are the same, we don't need to retag.
-        masm.orq(R1.valueReg(), R0.valueReg());
-        break;
-      case JSOP_BITXOR:
-        masm.xorl(R1.valueReg(), R0.valueReg());
-        masm.tagValue(JSVAL_TYPE_INT32, R0.valueReg(), R0);
-        break;
-      case JSOP_BITAND:
-        masm.andq(R1.valueReg(), R0.valueReg());
-        break;
-      case JSOP_LSH:
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ecx); // Unboxing R1 to ecx, clobbers R0.
-        masm.shll_cl(ExtractTemp0);
-        masm.boxValue(JSVAL_TYPE_INT32, ExtractTemp0, R0.valueReg());
-        break;
-      case JSOP_RSH:
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ecx);
-        masm.sarl_cl(ExtractTemp0);
-        masm.boxValue(JSVAL_TYPE_INT32, ExtractTemp0, R0.valueReg());
-        break;
-      case JSOP_URSH:
-        if (!allowDouble_) {
-            scratch.emplace(masm);
-            masm.movq(R0.valueReg(), *scratch);
-        }
-
-        masm.unboxInt32(R0, ExtractTemp0);
-        masm.unboxInt32(R1, ecx); // This clobbers R0
-
-        masm.shrl_cl(ExtractTemp0);
-        masm.test32(ExtractTemp0, ExtractTemp0);
-        if (allowDouble_) {
-            Label toUint;
-            masm.j(Assembler::Signed, &toUint);
-
-            // Box and return.
-            masm.boxValue(JSVAL_TYPE_INT32, ExtractTemp0, R0.valueReg());
-            EmitReturnFromIC(masm);
-
-            masm.bind(&toUint);
-            ScratchDoubleScope scratchDouble(masm);
-            masm.convertUInt32ToDouble(ExtractTemp0, scratchDouble);
-            masm.boxDouble(scratchDouble, R0, scratchDouble);
-        } else {
-            masm.j(Assembler::Signed, &revertRegister);
-            masm.boxValue(JSVAL_TYPE_INT32, ExtractTemp0, R0.valueReg());
-        }
-        break;
-      default:
-        MOZ_CRASH("Unhandled op in BinaryArith_Int32");
-    }
-
-    // Return from stub.
-    EmitReturnFromIC(masm);
-
-    if (op_ == JSOP_MUL) {
-        masm.bind(&maybeNegZero);
-
-        // Result is -0 if exactly one of lhs or rhs is negative.
-        {
-            ScratchRegisterScope scratch(masm);
-            masm.movl(R0.valueReg(), scratch);
-            masm.orl(R1.valueReg(), scratch);
-            masm.j(Assembler::Signed, &failure);
-        }
-
-        // Result is +0.
-        masm.moveValue(Int32Value(0), R0);
-        EmitReturnFromIC(masm);
-    }
-
-    // Revert the content of R0 in the fallible >>> case.
-    if (op_ == JSOP_URSH && !allowDouble_) {
-        // Scope continuation from JSOP_URSH case above.
-        masm.bind(&revertRegister);
-        // Restore tag and payload.
-        masm.movq(*scratch, R0.valueReg());
-        // Fall through to failure.
-    }
-    // Failure case - jump to next stub
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-
-    return true;
-}
-
-} // namespace jit
-} // namespace js
deleted file mode 100644
--- a/js/src/jit/x86/SharedIC-x86.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sts=4 et sw=4 tw=99:
- * 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 "jit/BaselineCompiler.h"
-#include "jit/BaselineIC.h"
-#include "jit/BaselineJIT.h"
-#include "jit/Linker.h"
-#include "jit/SharedICHelpers.h"
-
-#include "jit/MacroAssembler-inl.h"
-
-using namespace js;
-using namespace js::jit;
-
-namespace js {
-namespace jit {
-
-// ICBinaryArith_Int32
-
-bool
-ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler& masm)
-{
-    // Guard that R0 is an integer and R1 is an integer.
-    Label failure;
-    masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
-    masm.branchTestInt32(Assembler::NotEqual, R1, &failure);
-
-    // Add R0 and R1.  Don't need to explicitly unbox, just use the TailCallReg which
-    // should be available.
-    Register scratchReg = ICTailCallReg;
-
-    Label revertRegister, maybeNegZero;
-    switch(op_) {
-      case JSOP_ADD:
-        // Add R0 and R1.  Don't need to explicitly unbox.
-        masm.movl(R0.payloadReg(), scratchReg);
-        masm.addl(R1.payloadReg(), scratchReg);
-
-        // Just jump to failure on overflow.  R0 and R1 are preserved, so we can just jump to
-        // the next stub.
-        masm.j(Assembler::Overflow, &failure);
-
-        // Just overwrite the payload, the tag is still fine.
-        masm.movl(scratchReg, R0.payloadReg());
-        break;
-      case JSOP_SUB:
-        masm.movl(R0.payloadReg(), scratchReg);
-        masm.subl(R1.payloadReg(), scratchReg);
-        masm.j(Assembler::Overflow, &failure);
-        masm.movl(scratchReg, R0.payloadReg());
-        break;
-      case JSOP_MUL:
-        masm.movl(R0.payloadReg(), scratchReg);
-        masm.imull(R1.payloadReg(), scratchReg);
-        masm.j(Assembler::Overflow, &failure);
-
-        masm.test32(scratchReg, scratchReg);
-        masm.j(Assembler::Zero, &maybeNegZero);
-
-        masm.movl(scratchReg, R0.payloadReg());
-        break;
-      case JSOP_DIV:
-      {
-        // Prevent division by 0.
-        masm.branchTest32(Assembler::Zero, R1.payloadReg(), R1.payloadReg(), &failure);
-
-        // Prevent negative 0 and -2147483648 / -1.
-        masm.branch32(Assembler::Equal, R0.payloadReg(), Imm32(INT32_MIN), &failure);
-
-        Label notZero;
-        masm.branch32(Assembler::NotEqual, R0.payloadReg(), Imm32(0), &notZero);
-        masm.branchTest32(Assembler::Signed, R1.payloadReg(), R1.payloadReg(), &failure);
-        masm.bind(&notZero);
-
-        // For idiv we need eax.
-        MOZ_ASSERT(R1.typeReg() == eax);
-        masm.movl(R0.payloadReg(), eax);
-        // Preserve R0.payloadReg()/edx, eax is JSVAL_TYPE_INT32.
-        masm.movl(R0.payloadReg(), scratchReg);
-        // Sign extend eax into edx to make (edx:eax), since idiv is 64-bit.
-        masm.cdq();
-        masm.idiv(R1.payloadReg());
-
-        // A remainder implies a double result.
-        masm.branchTest32(Assembler::NonZero, edx, edx, &revertRegister);
-
-        masm.movl(eax, R0.payloadReg());
-        break;
-      }
-      case JSOP_MOD:
-      {
-        // x % 0 always results in NaN.
-        masm.branchTest32(Assembler::Zero, R1.payloadReg(), R1.payloadReg(), &failure);
-
-        // Prevent negative 0 and -2147483648 % -1.
-        masm.branchTest32(Assembler::Zero, R0.payloadReg(), Imm32(0x7fffffff), &failure);
-
-        // For idiv we need eax.
-        MOZ_ASSERT(R1.typeReg() == eax);
-        masm.movl(R0.payloadReg(), eax);
-        // Preserve R0.payloadReg()/edx, eax is JSVAL_TYPE_INT32.
-        masm.movl(R0.payloadReg(), scratchReg);
-        // Sign extend eax into edx to make (edx:eax), since idiv is 64-bit.
-        masm.cdq();
-        masm.idiv(R1.payloadReg());
-
-        // Fail when we would need a negative remainder.
-        Label done;
-        masm.branchTest32(Assembler::NonZero, edx, edx, &done);
-        masm.branchTest32(Assembler::Signed, scratchReg, scratchReg, &revertRegister);
-        masm.branchTest32(Assembler::Signed, R1.payloadReg(), R1.payloadReg(), &revertRegister);
-
-        masm.bind(&done);
-        // Result is in edx, tag in ecx remains untouched.
-        MOZ_ASSERT(R0.payloadReg() == edx);
-        MOZ_ASSERT(R0.typeReg() == ecx);
-        break;
-      }
-      case JSOP_BITOR:
-        // We can overide R0, because the instruction is unfailable.
-        // The R0.typeReg() is also still intact.
-        masm.orl(R1.payloadReg(), R0.payloadReg());
-        break;
-      case JSOP_BITXOR:
-        masm.xorl(R1.payloadReg(), R0.payloadReg());
-        break;
-      case JSOP_BITAND:
-        masm.andl(R1.payloadReg(), R0.payloadReg());
-        break;
-      case JSOP_LSH:
-        // RHS needs to be in ecx for shift operations.
-        MOZ_ASSERT(R0.typeReg() == ecx);
-        masm.movl(R1.payloadReg(), ecx);
-        masm.shll_cl(R0.payloadReg());
-        // We need to tag again, because we overwrote it.
-        masm.tagValue(JSVAL_TYPE_INT32, R0.payloadReg(), R0);
-        break;
-      case JSOP_RSH:
-        masm.movl(R1.payloadReg(), ecx);
-        masm.sarl_cl(R0.payloadReg());
-        masm.tagValue(JSVAL_TYPE_INT32, R0.payloadReg(), R0);
-        break;
-      case JSOP_URSH:
-        if (!allowDouble_)
-            masm.movl(R0.payloadReg(), scratchReg);
-
-        masm.movl(R1.payloadReg(), ecx);
-        masm.shrl_cl(R0.payloadReg());
-        masm.test32(R0.payloadReg(), R0.payloadReg());
-        if (allowDouble_) {
-            Label toUint;
-            masm.j(Assembler::Signed, &toUint);
-
-            // Box and return.
-            masm.tagValue(JSVAL_TYPE_INT32, R0.payloadReg(), R0);
-            EmitReturnFromIC(masm);
-
-            masm.bind(&toUint);
-            masm.convertUInt32ToDouble(R0.payloadReg(), ScratchDoubleReg);
-            masm.boxDouble(ScratchDoubleReg, R0, ScratchDoubleReg);
-        } else {
-            masm.j(Assembler::Signed, &revertRegister);
-            masm.tagValue(JSVAL_TYPE_INT32, R0.payloadReg(), R0);
-        }
-        break;
-      default:
-       MOZ_CRASH("Unhandled op for BinaryArith_Int32.");
-    }
-
-    // Return.
-    EmitReturnFromIC(masm);
-
-    switch(op_) {
-      case JSOP_MUL:
-        masm.bind(&maybeNegZero);
-
-        // Result is -0 if exactly one of lhs or rhs is negative.
-        masm.movl(R0.payloadReg(), scratchReg);
-        masm.orl(R1.payloadReg(), scratchReg);
-        masm.j(Assembler::Signed, &failure);
-
-        // Result is +0.
-        masm.mov(ImmWord(0), R0.payloadReg());
-        EmitReturnFromIC(masm);
-        break;
-      case JSOP_DIV:
-      case JSOP_MOD:
-        masm.bind(&revertRegister);
-        masm.movl(scratchReg, R0.payloadReg());
-        masm.movl(ImmType(JSVAL_TYPE_INT32), R1.typeReg());
-        break;
-      case JSOP_URSH:
-        // Revert the content of R0 in the fallible >>> case.
-        if (!allowDouble_) {
-            masm.bind(&revertRegister);
-            masm.tagValue(JSVAL_TYPE_INT32, scratchReg, R0);
-        }
-        break;
-      default:
-        // No special failure handling required.
-        // Fall through to failure.
-        break;
-    }
-
-    // Failure case - jump to next stub
-    masm.bind(&failure);
-    EmitStubGuardFailure(masm);
-
-    return true;
-}
-
-} // namespace jit
-} // namespace js
--- a/js/src/moz.build
+++ b/js/src/moz.build
@@ -511,47 +511,44 @@ elif CONFIG['JS_CODEGEN_X86'] or CONFIG[
         UNIFIED_SOURCES += [
             'jit/x64/Assembler-x64.cpp',
             'jit/x64/Bailouts-x64.cpp',
             'jit/x64/BaselineCompiler-x64.cpp',
             'jit/x64/BaselineIC-x64.cpp',
             'jit/x64/CodeGenerator-x64.cpp',
             'jit/x64/Lowering-x64.cpp',
             'jit/x64/MacroAssembler-x64.cpp',
-            'jit/x64/SharedIC-x64.cpp',
             'jit/x64/Trampoline-x64.cpp',
         ]
     else:
         LOpcodesGenerated.inputs += ['jit/x86/LIR-x86.h']
         UNIFIED_SOURCES += [
             'jit/x86/Assembler-x86.cpp',
             'jit/x86/Bailouts-x86.cpp',
             'jit/x86/BaselineCompiler-x86.cpp',
             'jit/x86/BaselineIC-x86.cpp',
             'jit/x86/CodeGenerator-x86.cpp',
             'jit/x86/Lowering-x86.cpp',
             'jit/x86/MacroAssembler-x86.cpp',
-            'jit/x86/SharedIC-x86.cpp',
             'jit/x86/Trampoline-x86.cpp',
         ]
 elif CONFIG['JS_CODEGEN_ARM']:
     LOpcodesGenerated.inputs += ['jit/arm/LIR-arm.h']
     UNIFIED_SOURCES += [
         'jit/arm/Architecture-arm.cpp',
         'jit/arm/Assembler-arm.cpp',
         'jit/arm/Bailouts-arm.cpp',
         'jit/arm/BaselineCompiler-arm.cpp',
         'jit/arm/BaselineIC-arm.cpp',
         'jit/arm/CodeGenerator-arm.cpp',
         'jit/arm/disasm/Constants-arm.cpp',
         'jit/arm/disasm/Disasm-arm.cpp',
         'jit/arm/Lowering-arm.cpp',
         'jit/arm/MacroAssembler-arm.cpp',
         'jit/arm/MoveEmitter-arm.cpp',
-        'jit/arm/SharedIC-arm.cpp',
         'jit/arm/Trampoline-arm.cpp',
     ]
     if CONFIG['JS_SIMULATOR_ARM']:
         UNIFIED_SOURCES += [
             'jit/arm/Simulator-arm.cpp'
         ]
     elif CONFIG['OS_ARCH'] == 'Darwin':
         SOURCES += [
@@ -565,17 +562,16 @@ elif CONFIG['JS_CODEGEN_ARM64']:
         'jit/arm64/Assembler-arm64.cpp',
         'jit/arm64/Bailouts-arm64.cpp',
         'jit/arm64/BaselineIC-arm64.cpp',
         'jit/arm64/CodeGenerator-arm64.cpp',
         'jit/arm64/Disassembler-arm64.cpp',
         'jit/arm64/Lowering-arm64.cpp',
         'jit/arm64/MacroAssembler-arm64.cpp',
         'jit/arm64/MoveEmitter-arm64.cpp',
-        'jit/arm64/SharedIC-arm64.cpp',
         'jit/arm64/Trampoline-arm64.cpp',
         'jit/arm64/vixl/Assembler-vixl.cpp',
         'jit/arm64/vixl/Cpu-vixl.cpp',
         'jit/arm64/vixl/Decoder-vixl.cpp',
         'jit/arm64/vixl/Disasm-vixl.cpp',
         'jit/arm64/vixl/Instructions-vixl.cpp',
         'jit/arm64/vixl/Instrument-vixl.cpp',
         'jit/arm64/vixl/MacroAssembler-vixl.cpp',
@@ -610,17 +606,16 @@ elif CONFIG['JS_CODEGEN_MIPS32'] or CONF
             'jit/mips32/Assembler-mips32.cpp',
             'jit/mips32/Bailouts-mips32.cpp',
             'jit/mips32/BaselineCompiler-mips32.cpp',
             'jit/mips32/BaselineIC-mips32.cpp',
             'jit/mips32/CodeGenerator-mips32.cpp',
             'jit/mips32/Lowering-mips32.cpp',
             'jit/mips32/MacroAssembler-mips32.cpp',
             'jit/mips32/MoveEmitter-mips32.cpp',
-            'jit/mips32/SharedIC-mips32.cpp',
             'jit/mips32/Trampoline-mips32.cpp',
         ]
         if CONFIG['JS_SIMULATOR_MIPS32']:
             UNIFIED_SOURCES += [
                 'jit/mips32/Simulator-mips32.cpp'
             ]
     elif CONFIG['JS_CODEGEN_MIPS64']:
         LOpcodesGenerated.inputs += ['jit/mips64/LIR-mips64.h']
@@ -629,17 +624,16 @@ elif CONFIG['JS_CODEGEN_MIPS32'] or CONF
             'jit/mips64/Assembler-mips64.cpp',
             'jit/mips64/Bailouts-mips64.cpp',
             'jit/mips64/BaselineCompiler-mips64.cpp',
             'jit/mips64/BaselineIC-mips64.cpp',
             'jit/mips64/CodeGenerator-mips64.cpp',
             'jit/mips64/Lowering-mips64.cpp',
             'jit/mips64/MacroAssembler-mips64.cpp',
             'jit/mips64/MoveEmitter-mips64.cpp',
-            'jit/mips64/SharedIC-mips64.cpp',
             'jit/mips64/Trampoline-mips64.cpp',
         ]
         if CONFIG['JS_SIMULATOR_MIPS64']:
             UNIFIED_SOURCES += [
                 'jit/mips64/Simulator-mips64.cpp'
             ]
 
 if CONFIG['OS_ARCH'] == 'WINNT':
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -7507,17 +7507,17 @@ nsCSSFrameConstructor::ContentRangeInser
   FlattenedChildIterator iter(insertion.mContainer);
   bool haveNoXBLChildren = !iter.XBLInvolved() || !iter.GetNextChild();
   if (aStartChild->GetPreviousSibling() &&
       parentType == eTypeBlock && haveNoXBLChildren) {
     // If there's a text node in the normal content list just before the
     // new nodes, and it has no frame, make a frame construction item for
     // it, because it might need a frame now.  No need to do this if our
     // parent type is not block, though, since WipeContainingBlock
-    // already handles that sitation.
+    // already handles that situation.
     AddTextItemIfNeeded(state, insertion, aStartChild->GetPreviousSibling(),
                         items);
   }
 
   if (isSingleInsert) {
     AddFrameConstructionItems(state, aStartChild,
                               aStartChild->IsRootOfAnonymousSubtree(),
                               insertion, items);
@@ -7529,17 +7529,17 @@ nsCSSFrameConstructor::ContentRangeInser
     }
   }
 
   if (aEndChild && parentType == eTypeBlock && haveNoXBLChildren) {
     // If there's a text node in the normal content list just after the
     // new nodes, and it has no frame, make a frame construction item for
     // it, because it might need a frame now.  No need to do this if our
     // parent type is not block, though, since WipeContainingBlock
-    // already handles that sitation.
+    // already handles that situation.
     AddTextItemIfNeeded(state, insertion, aEndChild, items);
   }
 
   // Perform special check for diddling around with the frames in
   // a special inline frame.
   // If we're appending before :after content, then we're not really
   // appending, so let WipeContainingBlock know that.
   LAYOUT_PHASE_TEMP_EXIT();
--- a/mobile/android/base/java/org/mozilla/gecko/customtabs/CustomTabsActivity.java
+++ b/mobile/android/base/java/org/mozilla/gecko/customtabs/CustomTabsActivity.java
@@ -649,16 +649,20 @@ public class CustomTabsActivity extends 
     }
 
     @Override
     public GeckoResult<GeckoSession> onNewSession(final GeckoSession session, final String uri) {
         // We should never get here because we abort loads that need a new session in onLoadRequest()
         throw new IllegalStateException("Unexpected new session");
     }
 
+    public void onLoadError(final GeckoSession session, final String urlStr,
+                            final int category, final int error) {
+    }
+
     /* GeckoSession.ProgressDelegate */
     @Override
     public void onPageStart(GeckoSession session, String url) {
         mCurrentUrl = url;
         mCanStop = true;
         updateActionBar();
         updateCanStop();
     }
--- a/mobile/android/base/java/org/mozilla/gecko/webapps/WebAppActivity.java
+++ b/mobile/android/base/java/org/mozilla/gecko/webapps/WebAppActivity.java
@@ -450,16 +450,20 @@ public class WebAppActivity extends AppC
     }
 
     @Override
     public GeckoResult<GeckoSession> onNewSession(final GeckoSession session, final String uri) {
         // We should never get here because we abort loads that need a new session in onLoadRequest()
         throw new IllegalStateException("Unexpected new session");
     }
 
+    public void onLoadError(final GeckoSession session, final String urlStr,
+                            final int category, final int error) {
+    }
+
     private void updateFullScreen() {
         boolean fullScreen = mIsFullScreenContent || mIsFullScreenMode;
         if (ActivityUtils.isFullScreen(this) == fullScreen) {
             return;
         }
 
         ActivityUtils.setFullScreen(this, fullScreen);
     }
--- a/mobile/android/chrome/geckoview/GeckoViewNavigationContent.js
+++ b/mobile/android/chrome/geckoview/GeckoViewNavigationContent.js
@@ -37,12 +37,28 @@ class GeckoViewNavigationContent extends
     // TODO: Remove this when we have a sensible error API.
     if (aUri && aUri.displaySpec.startsWith("about:certerror")) {
       addEventListener("click", ErrorPageEventHandler, true);
     }
 
     return LoadURIDelegate.load(content, this.eventDispatcher,
                                 aUri, aWhere, aFlags);
   }
+
+  // nsILoadURIDelegate.
+  handleLoadError(aUri, aError, aErrorModule) {
+    debug `handleLoadError: uri=${aUri && aUri.spec}
+                             uri2=${aUri && aUri.displaySpec}
+                             error=${aError}`;
+
+    const handled = LoadURIDelegate.handleLoadError(content, this.eventDispatcher,
+                                                    aUri, aError, aErrorModule);
+    this.eventDispatcher.sendRequest({
+      type: "GeckoView:PageStop",
+      sucess: false,
+    });
+
+    return handled;
+  }
 }
 
 let {debug, warn} = GeckoViewNavigationContent.initLogging("GeckoViewNavigation");
 let module = GeckoViewNavigationContent.create(this);
--- a/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/NavigationDelegateTest.kt
+++ b/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/NavigationDelegateTest.kt
@@ -23,16 +23,64 @@ import org.junit.Ignore
 import org.junit.Test
 import org.junit.runner.RunWith
 
 @RunWith(AndroidJUnit4::class)
 @MediumTest
 @ReuseSession(false)
 class NavigationDelegateTest : BaseSessionTest() {
 
+    fun loadExpectError(testUri: String, expectedCategory: Int,
+                        expectedError: Int) {
+        sessionRule.session.loadUri(testUri);
+        sessionRule.waitForPageStop()
+
+        sessionRule.forCallbacksDuringWait(
+            object : Callbacks.ProgressDelegate, Callbacks.NavigationDelegate {
+            @AssertCalled(count = 1, order = [1])
+            override fun onLoadRequest(session: GeckoSession, uri: String,
+                                       where: Int, flags: Int): GeckoResult<Boolean>? {
+                assertThat("URI should be " + testUri, uri, equalTo(testUri))
+                return null
+            }
+
+            @AssertCalled(count = 1, order = [2])
+            override fun onLoadError(session: GeckoSession, uri: String,
+                                     category: Int, error: Int) {
+                assertThat("Error category should match", category,
+                           equalTo(expectedCategory))
+                assertThat("Error should match", error,
+                           equalTo(expectedError))
+            }
+
+            @AssertCalled(count = 1, order = [3])
+            override fun onPageStop(session: GeckoSession, success: Boolean) {
+                assertThat("Load should fail", success, equalTo(false))
+            }
+        })
+    }
+
+    @Test fun loadFileNotFound() {
+        loadExpectError("file:///test.mozilla",
+                        GeckoSession.NavigationDelegate.ERROR_CATEGORY_URI,
+                        GeckoSession.NavigationDelegate.ERROR_FILE_NOT_FOUND)
+    }
+
+    @Test fun loadUnknownHost() {
+        loadExpectError(INVALID_URI,
+                        GeckoSession.NavigationDelegate.ERROR_CATEGORY_URI,
+                        GeckoSession.NavigationDelegate.ERROR_UNKNOWN_HOST)
+    }
+
+    @Test fun loadBadPort() {
+        loadExpectError("http://localhost:1/",
+                        GeckoSession.NavigationDelegate.ERROR_CATEGORY_NETWORK,
+                        GeckoSession.NavigationDelegate.ERROR_PORT_BLOCKED)
+    }
+
     @Setting(key = Setting.Key.USE_TRACKING_PROTECTION, value = "true")
     @Test fun trackingProtectionBasic() {
         val category = TrackingProtectionDelegate.CATEGORY_TEST;
         sessionRule.runtime.settings.trackingProtectionCategories = category
         sessionRule.session.loadTestPath(TRACKERS_PATH)
 
         sessionRule.waitUntilCalled(
                 object : Callbacks.TrackingProtectionDelegate {
--- a/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/ProgressDelegateTest.kt
+++ b/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/ProgressDelegateTest.kt
@@ -50,47 +50,16 @@ class ProgressDelegateTest : BaseSession
             @AssertCalled(count = 1, order = [3])
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 assertThat("Session should not be null", session, notNullValue())
                 assertThat("Load should succeed", success, equalTo(true))
             }
         })
     }
 
-    fun loadExpectNetError(testUri: String) {
-        sessionRule.session.loadUri(testUri);
-        sessionRule.waitForPageStop()
-
-        sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate, Callbacks.NavigationDelegate {
-            @AssertCalled(count = 2)
-            override fun onLoadRequest(session: GeckoSession, uri: String,
-                                       where: Int, flags: Int): GeckoResult<Boolean>? {
-                if (sessionRule.currentCall.counter == 1) {
-                    assertThat("URI should be " + testUri, uri, equalTo(testUri));
-                } else {
-                    assertThat("URI should be about:neterror", uri, startsWith("about:neterror"));
-                }
-                return null
-            }
-
-            @AssertCalled(count = 1)
-            override fun onPageStop(session: GeckoSession, success: Boolean) {
-                assertThat("Load should fail", success, equalTo(false))
-            }
-        })
-    }
-
-    @Test fun loadUnknownHost() {
-        loadExpectNetError(INVALID_URI)
-    }
-
-    @Test fun loadBadPort() {
-        loadExpectNetError("http://localhost:1/")
-    }
-
     @Ignore
     @Test fun multipleLoads() {
         sessionRule.session.loadUri(INVALID_URI)
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStops(2)
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
             @AssertCalled(count = 2, order = [1, 3])
--- a/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/TestRunnerActivity.java
+++ b/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/TestRunnerActivity.java
@@ -56,16 +56,21 @@ public class TestRunnerActivity extends 
             // Allow Gecko to load all URIs
             return GeckoResult.fromValue(false);
         }
 
         @Override
         public GeckoResult<GeckoSession> onNewSession(GeckoSession session, String uri) {
             return GeckoResult.fromValue(createBackgroundSession(session.getSettings()));
         }
+
+        @Override
+        public void onLoadError(GeckoSession session, String uri, int category, int error) {
+
+        }
     };
 
     private GeckoSession.ContentDelegate mContentDelegate = new GeckoSession.ContentDelegate() {
         @Override
         public void onTitleChange(GeckoSession session, String title) {
 
         }
 
--- a/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/util/Callbacks.kt
+++ b/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/util/Callbacks.kt
@@ -54,17 +54,21 @@ class Callbacks private constructor() {
         }
 
         override fun onLoadRequest(session: GeckoSession, uri: String, where: Int,
                                    flags: Int): GeckoResult<Boolean>? {
             return null
         }
 
         override fun onNewSession(session: GeckoSession, uri: String): GeckoResult<GeckoSession>? {
-            return null;
+            return null
+        }
+
+        override fun onLoadError(session: GeckoSession, uri: String,
+                                 category: Int, error: Int) {
         }
     }
 
     interface PermissionDelegate : GeckoSession.PermissionDelegate {
         override fun onAndroidPermissionsRequest(session: GeckoSession, permissions: Array<out String>, callback: GeckoSession.PermissionDelegate.Callback) {
             callback.reject()
         }
 
--- a/mobile/android/geckoview/src/main/java/org/mozilla/geckoview/GeckoSession.java
+++ b/mobile/android/geckoview/src/main/java/org/mozilla/geckoview/GeckoSession.java
@@ -10,16 +10,17 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.net.URLConnection;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.UUID;
 
 import org.mozilla.gecko.annotation.WrapForJNI;
 import org.mozilla.gecko.EventDispatcher;
+import org.mozilla.gecko.GeckoAppShell;
 import org.mozilla.gecko.gfx.LayerSession;
 import org.mozilla.gecko.GeckoEditableChild;
 import org.mozilla.gecko.GeckoThread;
 import org.mozilla.gecko.IGeckoEditableParent;
 import org.mozilla.gecko.mozglue.JNIObject;
 import org.mozilla.gecko.NativeQueue;
 import org.mozilla.gecko.util.BundleEventListener;
 import org.mozilla.gecko.util.EventCallback;
@@ -158,16 +159,17 @@ public class GeckoSession extends LayerS
             }
         };
 
     private final GeckoSessionHandler<NavigationDelegate> mNavigationHandler =
         new GeckoSessionHandler<NavigationDelegate>(
             "GeckoViewNavigation", this,
             new String[]{
                 "GeckoView:LocationChange",
+                "GeckoView:OnLoadError",
                 "GeckoView:OnLoadRequest",
                 "GeckoView:OnNewSession"
             }
         ) {
             // This needs to match nsIBrowserDOMWindow.idl
             private int convertGeckoTarget(int geckoTarget) {
                 switch (geckoTarget) {
                     case 0: // OPEN_DEFAULTWINDOW
@@ -178,16 +180,115 @@ public class GeckoSession extends LayerS
                 }
             }
 
             // The flags are already matched with nsIDocShell.idl.
             private int filterFlags(int flags) {
                 return flags & NavigationDelegate.LOAD_REQUEST_IS_USER_TRIGGERED;
             }
 
+            private @NavigationDelegate.LoadErrorCategory int getErrorCategory(
+                    long errorModule, @NavigationDelegate.LoadError int error) {
+                // Match flags with XPCOM ErrorList.h.
+                if (errorModule == 21) {
+                    return NavigationDelegate.ERROR_CATEGORY_SECURITY;
+                }
+                return error & 0xF;
+            }
+
+            private @NavigationDelegate.LoadError int convertGeckoError(
+                    long geckoError, int geckoErrorModule, int geckoErrorClass) {
+                // Match flags with XPCOM ErrorList.h.
+                // safebrowsing
+                if (geckoError == 0x805D001FL) {
+                    return NavigationDelegate.ERROR_SAFEBROWSING_PHISHING_URI;
+                }
+                if (geckoError == 0x805D001EL) {
+                    return NavigationDelegate.ERROR_SAFEBROWSING_MALWARE_URI;
+                }
+                if (geckoError == 0x805D0023L) {
+                    return NavigationDelegate.ERROR_SAFEBROWSING_UNWANTED_URI;
+                }
+                if (geckoError == 0x805D0026L) {
+                    return NavigationDelegate.ERROR_SAFEBROWSING_HARMFUL_URI;
+                }
+                // content
+                if (geckoError == 0x805E0010L) {
+                    return NavigationDelegate.ERROR_CONTENT_CRASHED;
+                }
+                if (geckoError == 0x804B001BL) {
+                    return NavigationDelegate.ERROR_INVALID_CONTENT_ENCODING;
+                }
+                if (geckoError == 0x804B004AL) {
+                    return NavigationDelegate.ERROR_UNSAFE_CONTENT_TYPE;
+                }
+                if (geckoError == 0x804B001DL) {
+                    return NavigationDelegate.ERROR_CORRUPTED_CONTENT;
+                }
+                // network
+                if (geckoError == 0x804B0014L) {
+                    return NavigationDelegate.ERROR_NET_RESET;
+                }
+                if (geckoError == 0x804B0047L) {
+                    return NavigationDelegate.ERROR_NET_INTERRUPT;
+                }
+                if (geckoError == 0x804B000EL) {
+                    return NavigationDelegate.ERROR_NET_TIMEOUT;
+                }
+                if (geckoError == 0x804B000DL) {
+                    return NavigationDelegate.ERROR_CONNECTION_REFUSED;
+                }
+                if (geckoError == 0x804B0033L) {
+                    return NavigationDelegate.ERROR_UNKNOWN_SOCKET_TYPE;
+                }
+                if (geckoError == 0x804B001FL) {
+                    return NavigationDelegate.ERROR_REDIRECT_LOOP;
+                }
+                if (geckoError == 0x804B0010L) {
+                    return NavigationDelegate.ERROR_OFFLINE;
+                }
+                if (geckoError == 0x804B0013L) {
+                    return NavigationDelegate.ERROR_PORT_BLOCKED;
+                }
+                // uri
+                if (geckoError == 0x804B0012L) {
+                    return NavigationDelegate.ERROR_UNKNOWN_PROTOCOL;
+                }
+                if (geckoError == 0x804B001EL) {
+                    return NavigationDelegate.ERROR_UNKNOWN_HOST;
+                }
+                if (geckoError == 0x804B000AL) {
+                    return NavigationDelegate.ERROR_MALFORMED_URI;
+                }
+                if (geckoError == 0x80520012L) {
+                    return NavigationDelegate.ERROR_FILE_NOT_FOUND;
+                }
+                if (geckoError == 0x80520015L) {
+                    return NavigationDelegate.ERROR_FILE_ACCESS_DENIED;
+                }
+                // proxy
+                if (geckoError == 0x804B002AL) {
+                    return NavigationDelegate.ERROR_UNKNOWN_PROXY_HOST;
+                }
+                if (geckoError == 0x804B0048L) {
+                    return NavigationDelegate.ERROR_PROXY_CONNECTION_REFUSED;
+                }
+
+                if (geckoErrorModule == 21) {
+                    if (geckoErrorClass == 1) {
+                        return NavigationDelegate.ERROR_SECURITY_SSL;
+                    }
+                    if (geckoErrorClass == 2) {
+                        return NavigationDelegate.ERROR_SECURITY_BAD_CERT;
+                    }
+                }
+
+                return NavigationDelegate.ERROR_UNKNOWN;
+            }
+
             @Override
             public void handleMessage(final NavigationDelegate delegate,
                                       final String event,
                                       final GeckoBundle message,
                                       final EventCallback callback) {
                 if ("GeckoView:LocationChange".equals(event)) {
                     if (message.getBoolean("isTopLevel")) {
                         delegate.onLocationChange(GeckoSession.this,
@@ -219,16 +320,28 @@ public class GeckoSession extends LayerS
                         }
                     }, new GeckoResult.OnExceptionListener<Void>() {
                         @Override
                         public GeckoResult<Void> onException(Throwable exception) throws Throwable {
                             callback.sendError(exception.getMessage());
                             return null;
                         }
                     });
+                } else if ("GeckoView:OnLoadError".equals(event)) {
+                    final String uri = message.getString("uri");
+                    final long errorCode = message.getLong("error");
+                    final int errorModule = message.getInt("errorModule");
+                    final int errorClass = message.getInt("errorClass");
+                    final int error = convertGeckoError(errorCode, errorModule,
+                                                        errorClass);
+                    final int errorCat = getErrorCategory(errorModule, error);
+
+                    delegate.onLoadError(GeckoSession.this, uri, errorCat, error);
+
+                    callback.sendSuccess(!GeckoAppShell.isFennec());
                 } else if ("GeckoView:OnNewSession".equals(event)) {
                     final String uri = message.getString("uri");
                     final GeckoResult<GeckoSession> result = delegate.onNewSession(GeckoSession.this, uri);
                     if (result == null) {
                         callback.sendSuccess(null);
                         return;
                     }
 
@@ -2253,16 +2366,93 @@ public class GeckoSession extends LayerS
         * @param session The GeckoSession that initiated the callback.
         * @param uri The URI to be loaded.
         *
         * @return A {@link GeckoResult} which holds the returned GeckoSession. May be null, in
          *        which case the request for a new window by web content will fail. e.g.,
          *        <code>window.open()</code> will return null.
         */
         @Nullable GeckoResult<GeckoSession> onNewSession(@NonNull GeckoSession session, @NonNull String uri);
+
+        @IntDef({ERROR_CATEGORY_UNKNOWN, ERROR_CATEGORY_SECURITY,
+                 ERROR_CATEGORY_NETWORK, ERROR_CATEGORY_CONTENT,
+                 ERROR_CATEGORY_URI, ERROR_CATEGORY_PROXY,
+                 ERROR_CATEGORY_SAFEBROWSING})
+        public @interface LoadErrorCategory {}
+
+        @IntDef({ERROR_UNKNOWN, ERROR_SECURITY_SSL, ERROR_SECURITY_BAD_CERT,
+                 ERROR_NET_RESET, ERROR_NET_INTERRUPT, ERROR_NET_TIMEOUT,
+                 ERROR_CONNECTION_REFUSED, ERROR_UNKNOWN_PROTOCOL,
+                 ERROR_UNKNOWN_HOST, ERROR_UNKNOWN_SOCKET_TYPE,
+                 ERROR_UNKNOWN_PROXY_HOST, ERROR_MALFORMED_URI,
+                 ERROR_REDIRECT_LOOP, ERROR_SAFEBROWSING_PHISHING_URI,
+                 ERROR_SAFEBROWSING_MALWARE_URI, ERROR_SAFEBROWSING_UNWANTED_URI,
+                 ERROR_SAFEBROWSING_HARMFUL_URI, ERROR_CONTENT_CRASHED,
+                 ERROR_OFFLINE, ERROR_PORT_BLOCKED,
+                 ERROR_PROXY_CONNECTION_REFUSED, ERROR_FILE_NOT_FOUND,
+                 ERROR_FILE_ACCESS_DENIED, ERROR_INVALID_CONTENT_ENCODING,
+                 ERROR_UNSAFE_CONTENT_TYPE, ERROR_CORRUPTED_CONTENT})
+        public @interface LoadError {}
+
+        public static final int ERROR_CATEGORY_UNKNOWN = 0x1;
+        public static final int ERROR_CATEGORY_SECURITY = 0x2;
+        public static final int ERROR_CATEGORY_NETWORK = 0x3;
+        public static final int ERROR_CATEGORY_CONTENT = 0x4;
+        public static final int ERROR_CATEGORY_URI = 0x5;
+        public static final int ERROR_CATEGORY_PROXY = 0x6;
+        public static final int ERROR_CATEGORY_SAFEBROWSING = 0x7;
+
+        public static final int ERROR_UNKNOWN = 0x11;
+
+        // Security
+        public static final int ERROR_SECURITY_SSL = 0x22;
+        public static final int ERROR_SECURITY_BAD_CERT = 0x32;
+
+        // Network
+        public static final int ERROR_NET_INTERRUPT = 0x23;
+        public static final int ERROR_NET_TIMEOUT = 0x33;
+        public static final int ERROR_CONNECTION_REFUSED = 0x43;
+        public static final int ERROR_UNKNOWN_SOCKET_TYPE = 0x53;
+        public static final int ERROR_REDIRECT_LOOP = 0x63;
+        public static final int ERROR_OFFLINE = 0x73;
+        public static final int ERROR_PORT_BLOCKED = 0x83;
+        public static final int ERROR_NET_RESET = 0x93;
+
+        // Content
+        public static final int ERROR_UNSAFE_CONTENT_TYPE = 0x24;
+        public static final int ERROR_CORRUPTED_CONTENT = 0x34;
+        public static final int ERROR_CONTENT_CRASHED = 0x44;
+        public static final int ERROR_INVALID_CONTENT_ENCODING = 0x54;
+
+        // URI
+        public static final int ERROR_UNKNOWN_HOST = 0x25;
+        public static final int ERROR_MALFORMED_URI = 0x35;
+        public static final int ERROR_UNKNOWN_PROTOCOL = 0x45;
+        public static final int ERROR_FILE_NOT_FOUND = 0x55;
+        public static final int ERROR_FILE_ACCESS_DENIED = 0x65;
+
+        // Proxy
+        public static final int ERROR_PROXY_CONNECTION_REFUSED = 0x26;
+        public static final int ERROR_UNKNOWN_PROXY_HOST = 0x36;
+
+        // Safebrowsing
+        public static final int ERROR_SAFEBROWSING_MALWARE_URI = 0x27;
+        public static final int ERROR_SAFEBROWSING_UNWANTED_URI = 0x37;
+        public static final int ERROR_SAFEBROWSING_HARMFUL_URI = 0x47;
+        public static final int ERROR_SAFEBROWSING_PHISHING_URI = 0x57;
+
+        /**
+         * @param session The GeckoSession that initiated the callback.
+         * @param uri The URI that failed to load.
+         * @param category The error category.
+         * @param error The error type.
+         */
+        void onLoadError(GeckoSession session, String uri,
+                         @LoadErrorCategory int category,
+                         @LoadError int error);
     }
 
     /**
      * GeckoSession applications implement this interface to handle prompts triggered by
      * content in the GeckoSession, such as alerts, authentication dialogs, and select list
      * pickers.
      **/
     public interface PromptDelegate {
--- a/mobile/android/geckoview_example/src/main/java/org/mozilla/geckoview_example/GeckoViewActivity.java
+++ b/mobile/android/geckoview_example/src/main/java/org/mozilla/geckoview_example/GeckoViewActivity.java
@@ -584,16 +584,23 @@ public class GeckoViewActivity extends A
             intent.setAction(Intent.ACTION_VIEW);
             intent.setData(Uri.parse(uri));
             intent.putExtra("session", newSession);
 
             startActivity(intent);
 
             return GeckoResult.fromValue(newSession);
         }
+
+        public void onLoadError(final GeckoSession session, final String uri,
+                                final int category, final int error) {
+            Log.d(LOGTAG, "onLoadError=" + uri +
+                  " error category=" + category +
+                  " error=" + error);
+        }
     }
 
     private class ExampleTrackingProtectionDelegate implements GeckoSession.TrackingProtectionDelegate {
         private int mBlockedAds = 0;
         private int mBlockedAnalytics = 0;
         private int mBlockedSocial = 0;
         private int mBlockedContent = 0;
         private int mBlockedTest = 0;
--- a/mobile/android/modules/geckoview/LoadURIDelegate.jsm
+++ b/mobile/android/modules/geckoview/LoadURIDelegate.jsm
@@ -7,17 +7,17 @@
 var EXPORTED_SYMBOLS = ["LoadURIDelegate"];
 
 ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
 
 XPCOMUtils.defineLazyModuleGetters(this, {
   Services: "resource://gre/modules/Services.jsm",
 });
 
-var LoadURIDelegate = {
+const LoadURIDelegate = {
   // Delegate URI loading to the app.
   // Return whether the loading has been handled.
   load: function(aWindow, aEventDispatcher, aUri, aWhere, aFlags) {
     if (!aWindow) {
       return false;
     }
 
     const message = {
@@ -34,10 +34,41 @@ var LoadURIDelegate = {
       // There was an error or listener was not registered in GeckoSession,
       // treat as unhandled.
       handled = false;
     });
     Services.tm.spinEventLoopUntil(() =>
         aWindow.closed || handled !== undefined);
 
     return handled || false;
+  },
+
+  handleLoadError: function(aWindow, aEventDispatcher, aUri, aError,
+                            aErrorModule) {
+    let errorClass = 0;
+    try {
+      let nssErrorsService = Cc["@mozilla.org/nss_errors_service;1"]
+                             .getService(Ci.nsINSSErrorsService);
+      errorClass = nssErrorsService.getErrorClass(aError);
+    } catch (e) {}
+
+    const msg = {
+      type: "GeckoView:OnLoadError",
+      uri: aUri.spec,
+      error: aError,
+      errorModule: aErrorModule,
+      errorClass
+    };
+
+    let handled = undefined;
+    aEventDispatcher.sendRequestForResult(msg).then(response => {
+      handled = response;
+    }, () => {
+      // There was an error or listener was not registered in GeckoSession,
+      // treat as unhandled.
+      handled = false;
+    });
+    Services.tm.spinEventLoopUntil(() =>
+        aWindow.closed || handled !== undefined);
+
+    return handled || false;
   }
 };
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -5848,8 +5848,14 @@ pref("general.document_open_conversion_d
 // documentElement and document.body are passive by default.
 pref("dom.event.default_to_passive_touch_listeners", true);
 
 // Enable FastBlock?
 pref("browser.fastblock.enabled", false);
 // The timeout (ms) since navigation start, all tracker connections been made
 // after this timeout will be canceled.
 pref("browser.fastblock.timeout", 5000);
+
+// Disables clipboard reads and writes by default.
+pref("dom.events.asyncClipboard", false);
+pref("dom.events.asyncClipboard.dataTransfer", false);
+// Should only be enabled in tests
+pref("dom.events.testing.asyncClipboard", false);
--- a/security/sandbox/linux/broker/SandboxBrokerPolicyFactory.cpp
+++ b/security/sandbox/linux/broker/SandboxBrokerPolicyFactory.cpp
@@ -3,16 +3,17 @@
 /* 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 "SandboxBrokerPolicyFactory.h"
 #include "SandboxInfo.h"
 #include "SandboxLogging.h"
 
+#include "base/shared_memory.h"
 #include "mozilla/Array.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/SandboxSettings.h"
 #include "mozilla/UniquePtr.h"
 #include "mozilla/UniquePtrExtensions.h"
 #include "mozilla/SandboxLaunch.h"
 #include "mozilla/dom/ContentChild.h"
@@ -185,17 +186,16 @@ AddLdconfigPaths(SandboxBroker::Policy* 
 }
 
 SandboxBrokerPolicyFactory::SandboxBrokerPolicyFactory()
 {
   // Policy entries that are the same in every process go here, and
   // are cached over the lifetime of the factory.
 #if defined(MOZ_CONTENT_SANDBOX)
   SandboxBroker::Policy* policy = new SandboxBroker::Policy;
-  policy->AddDir(rdwrcr, "/dev/shm");
   // Write permssions
   //
   // Bug 1308851: NVIDIA proprietary driver when using WebGL
   policy->AddFilePrefix(rdwr, "/dev", "nvidia");
 
   // Bug 1312678: radeonsi/Intel with DRI when using WebGL
   policy->AddDir(rdwr, "/dev/dri");
 
@@ -504,16 +504,25 @@ SandboxBrokerPolicyFactory::GetContentPo
 #endif
   }
 
   if (allowAlsa) {
     // Bug 1309098: ALSA support
     policy->AddDir(rdwr, "/dev/snd");
   }
 
+  if (allowPulse) {
+    policy->AddDir(rdwrcr, "/dev/shm");
+  } else {
+    std::string shmPath("/dev/shm");
+    if (base::SharedMemory::AppendPosixShmPrefix(&shmPath, aPid)) {
+      policy->AddPrefix(rdwrcr, shmPath.c_str());
+    }
+  }
+
 #ifdef MOZ_WIDGET_GTK
   if (const auto userDir = g_get_user_runtime_dir()) {
     // Bug 1321134: DConf's single bit of shared memory
     // The leaf filename is "user" by default, but is configurable.
     nsPrintfCString shmPath("%s/dconf/", userDir);
     policy->AddPrefix(rdwrcr, shmPath.get());
     policy->AddAncestors(shmPath.get());
     if (allowPulse) {
--- a/servo/components/style/gecko/wrapper.rs
+++ b/servo/components/style/gecko/wrapper.rs
@@ -2069,25 +2069,25 @@ impl<'le> ::selectors::Element for Gecko
                     }
                 },
             }
         }
     }
 
     #[inline]
     fn is_root(&self) -> bool {
-        let parent_node = match self.as_node().parent_node() {
-            Some(parent_node) => parent_node,
-            None => return false,
-        };
-
-        if !parent_node.is_document() {
+        if self.as_node().get_bool_flag(nsINode_BooleanFlag::ParentIsContent) {
             return false;
         }
 
+        if !self.as_node().is_in_document() {
+            return false;
+        }
+
+        debug_assert!(self.as_node().parent_node().map_or(false, |p| p.is_document()));
         unsafe { bindings::Gecko_IsRootElement(self.0) }
     }
 
     fn is_empty(&self) -> bool {
         !self.as_node()
             .dom_children()
             .any(|child| unsafe { Gecko_IsSignificantChild(child.0, true) })
     }
--- a/testing/geckodriver/CONTRIBUTING.md
+++ b/testing/geckodriver/CONTRIBUTING.md
@@ -197,25 +197,25 @@ flag to geckodriver through WPT:
 [Web Platform Tests]: http://web-platform-tests.org/
 [cargo]: http://doc.crates.io/guide.html
 [headless mode]: https://developer.mozilla.org/en-US/Firefox/Headless_mode
 
 
 Submitting patches
 ------------------
 
-You can submit patches by uploading .diff files to Bugzilla or by
-sending them to [MozReview].
+You can submit patches by uploading .diff files to the `Testing ::
+geckodriver`` component in Bugzilla.  You may request review from
+_ato_, _automatedtester_, _jgraham_, or _whimboo_.
 
 Once you have contributed a couple of patches, we are happy to
 sponsor you in [becoming a Mozilla committer].  When you have been
 granted commit access level 1 you will have permission to use the
 [Firefox CI] to trigger your own “try runs” to test your changes.
 
-[MozReview]: http://mozilla-version-control-tools.readthedocs.io/en/latest/mozreview.html
 [becoming a Mozilla committer]: https://www.mozilla.org/en-US/about/governance/policies/commit/
 
 
 Communication
 =============
 
 The mailing list for geckodriver discussion is
 tools-marionette@lists.mozilla.org ([subscribe], [archive]).
--- a/testing/marionette/addon.js
+++ b/testing/marionette/addon.js
@@ -18,47 +18,22 @@ const ERRORS = {
   [-3]: "ERROR_CORRUPT_FILE: The file appears to be corrupt.",
   [-4]: "ERROR_FILE_ACCESS: There was an error accessing the filesystem.",
   [-5]: "ERROR_SIGNEDSTATE_REQUIRED: The addon must be signed and isn't.",
 };
 
 async function installAddon(file) {
   let install = await AddonManager.getInstallForFile(file);
 
-  return new Promise(resolve => {
-    if (install.error) {
-      throw new UnknownError(ERRORS[install.error]);
-    }
-
-    let addonId = install.addon.id;
-
-    let success = install => {
-      if (install.addon.id === addonId) {
-        install.removeListener(listener);
-        resolve(install.addon);
-      }
-    };
+  if (install.error) {
+    throw new UnknownError(ERRORS[install.error]);
+  }
 
-    let fail = install => {
-      if (install.addon.id === addonId) {
-        install.removeListener(listener);
-        throw new UnknownError(ERRORS[install.error]);
-      }
-    };
-
-    let listener = {
-      onDownloadCancelled: fail,
-      onDownloadFailed: fail,
-      onInstallCancelled: fail,
-      onInstallFailed: fail,
-      onInstallEnded: success,
-    };
-
-    install.addListener(listener);
-    install.install();
+  return install.install().catch(err => {
+    throw new UnknownError(ERRORS[install.error]);
   });
 }
 
 /** Installs addons by path and uninstalls by ID. */
 class Addon {
   /**
    * Install a Firefox addon.
    *
--- a/testing/marionette/doc/NewContributors.md
+++ b/testing/marionette/doc/NewContributors.md
@@ -112,31 +112,17 @@ Getting the code, running tests
 [virtualenv]: https://www.dabapps.com/blog/introduction-to-pip-and-virtualenv-python/
 [testing/marionette/client]: https://searchfox.org/mozilla-central/source/testing/marionette/client
 [testing/marionette/harness]: https://searchfox.org/mozilla-central/source/testing/marionette/harness
 
 
 Work on bugs and get code review
 --------------------------------
 
-Once you've completed the above basics, find a bug to work on
-at [Bugs Ahoy](https://www.joshmatthews.net/bugsahoy/?automation=1). If
-you don't find any, ask :whimboo, :maja_zf
-or :ato in #ateam for a good first bug to work on.
-
-To work on the bug that is suggested to you and push a patch up
-for review, follow the [Firefox Workflow] in hg.
-
-After testing your code locally, you will push your patch to be
-reviewed in MozReview.  To set up MozReview, see this [configuration]
-page.  (Note: the only kind of account you need for MozReview is
-Bugzilla (not LDAP) and you can only use HTTPS, not SSH.)
-
-[Firefox Workflow]: https://mozilla-version-control-tools.readthedocs.org/en/latest/hgmozilla/firefoxworkflow.html
-[configuration]: https://mozilla-version-control-tools.readthedocs.org/en/latest/mozreview/install-mercurial.html#configuring-mercurial-to-use-mozreview
+See <Patches.md> on how to submit patches.
 
 
 Resources
 ---------
 
   * Sometimes (often?) documentation is out-of-date.  If something looks
     off, do ask us for help!
 
--- a/testing/marionette/doc/Patches.md
+++ b/testing/marionette/doc/Patches.md
@@ -1,18 +1,17 @@
 Submitting patches
 ==================
 
-You can submit patches by uploading .diff files to Bugzilla or by
-sending them to [MozReview].
+You can submit patches by uploading .diff files to Bugzilla.
+Ask for review from _ato_, _automatedtester_, or _whimboo_.
 
 Once you have contributed a couple of patches, we are happy to
 sponsor you in [becoming a Mozilla committer].  When you have been
 granted commit access level 1 you will have permission to use the
 [Firefox CI] to trigger your own “try runs” to test your changes.
 
 This is a good try syntax to use when testing Marionette changes:
 
-    -b do -p linux,linux64,macosx64,win64,android-api-16 -u marionette-e10s,marionette-headless-e10s,xpcshell,web-platform-tests,firefox-ui-functional -t none
+	-b do -p linux,linux64,macosx64,win64,android-api-16 -u marionette-e10s,marionette-headless-e10s,xpcshell,web-platform-tests,firefox-ui-functional -t none
 
-[MozReview]: http://mozilla-version-control-tools.readthedocs.io/en/latest/mozreview.html
 [becoming a Mozilla committer]: https://www.mozilla.org/en-US/about/governance/policies/commit/
 [Firefox CI]: https://treeherder.mozilla.org/
rename from testing/mochitest/bootstrap.js
rename to testing/mochitest/api.js
--- a/testing/mochitest/bootstrap.js
+++ b/testing/mochitest/api.js
@@ -1,12 +1,14 @@
 /* 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/. */
 
+/* globals ExtensionAPI */
+
 ChromeUtils.import("resource://gre/modules/AppConstants.jsm");
 ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
 ChromeUtils.import("resource://gre/modules/Services.jsm");
 ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
 
 function loadChromeScripts(win) {
   Services.scriptloader.loadSubScript("chrome://mochikit/content/chrome-harness.js", win);
   Services.scriptloader.loadSubScript("chrome://mochikit/content/mochitest-e10s-utils.js", win);
@@ -33,20 +35,30 @@ const windowTracker = {
       if (documentURI !== "chrome://browser/content/browser.xul") {
         return;
       }
       loadChromeScripts(window);
     }
   },
 };
 
-function androidStartup(data, reason) {
+function androidStartup() {
   // Only browser chrome tests need help starting.
   let testRoot = Services.prefs.getStringPref("mochitest.testRoot", "");
   if (testRoot.endsWith("/chrome")) {
+    // The initial window is created from browser startup, which races
+    // against extension initialization.  If it has already been created,
+    // inject the test scripts now, otherwise wait for the browser window
+    // to show up.
+    let win = Services.wm.getMostRecentWindow("navigator:browser");
+    if (win) {
+      loadChromeScripts(win);
+      return;
+    }
+
     windowTracker.init();
   }
 }
 
 // ///// Desktop ///////
 
 var WindowListener = {
   // browser-test.js is only loaded into the first window. Setup that
@@ -89,34 +101,43 @@ function loadMochitest(e) {
   }
 
   WindowListener.setupWindow(win);
   Services.wm.addListener(WindowListener);
 
   loadChromeScripts(win);
 }
 
-function startup(data, reason) {
-  if (AppConstants.platform == "android") {
-    androidStartup(data, reason);
-  } else {
-    let win = Services.wm.getMostRecentWindow("navigator:browser");
-    // wait for event fired from start_desktop.js containing the
-    // suite and url to load
-    win.addEventListener("mochitest-load", loadMochitest);
+this.mochikit = class extends ExtensionAPI {
+  onStartup() {
+    let aomStartup = Cc["@mozilla.org/addons/addon-manager-startup;1"]
+                                 .getService(Ci.amIAddonManagerStartup);
+    const manifestURI = Services.io.newURI("manifest.json", null, this.extension.rootURI);
+    const targetURL = this.extension.rootURI.resolve("content/");
+    this.chromeHandle = aomStartup.registerChrome(manifestURI, [
+      ["content", "mochikit", targetURL],
+    ]);
+
+    if (AppConstants.platform == "android") {
+      androidStartup();
+    } else {
+      let win = Services.wm.getMostRecentWindow("navigator:browser");
+      // wait for event fired from start_desktop.js containing the
+      // suite and url to load
+      win.addEventListener("mochitest-load", loadMochitest);
+    }
   }
-}
 
-function shutdown(data, reason) {
-  if (AppConstants.platform != "android") {
-    let windows = Services.wm.getEnumerator("navigator:browser");
-    while (windows.hasMoreElements()) {
-      let win = windows.getNext().QueryInterface(Ci.nsIDOMWindow);
-      WindowListener.tearDownWindow(win);
+  onShutdown() {
+    if (AppConstants.platform != "android") {
+      let windows = Services.wm.getEnumerator("navigator:browser");
+      while (windows.hasMoreElements()) {
+        let win = windows.getNext().QueryInterface(Ci.nsIDOMWindow);
+        WindowListener.tearDownWindow(win);
+      }
+
+      Services.wm.removeListener(WindowListener);
     }
 
-    Services.wm.removeListener(WindowListener);
+    this.chromeHandle.destruct();
+    this.chromeHandle = null;
   }
-}
-
-function install(data, reason) {}
-function uninstall(data, reason) {}
-
+};
deleted file mode 100644
--- a/testing/mochitest/jar.mn
+++ /dev/null
@@ -1,42 +0,0 @@
-mochikit.jar:
-% content mochikit %content/
-  content/browser-harness.xul (browser-harness.xul)
-  content/browser-test.js (browser-test.js)
-  content/chrome-harness.js (chrome-harness.js)
-  content/mochitest-e10s-utils.js (mochitest-e10s-utils.js)
-  content/shutdown-leaks-collector.js (shutdown-leaks-collector.js)
-  content/ShutdownLeaksCollector.jsm (ShutdownLeaksCollector.jsm)
-  content/harness.xul (harness.xul)
-  content/redirect.html (redirect.html)
-  content/server.js (server.js)
-  content/chunkifyTests.js (chunkifyTests.js)
-  content/manifestLibrary.js (manifestLibrary.js)
-  content/nested_setup.js (nested_setup.js)
-  content/dynamic/getMyDirectory.sjs (dynamic/getMyDirectory.sjs)
-  content/static/harness.css (static/harness.css)
-  content/tests/SimpleTest/ChromePowers.js (tests/SimpleTest/ChromePowers.js)
-  content/tests/SimpleTest/EventUtils.js (tests/SimpleTest/EventUtils.js)
-  content/tests/SimpleTest/ExtensionTestUtils.js (tests/SimpleTest/ExtensionTestUtils.js)
-  content/tests/SimpleTest/AddTask.js (tests/SimpleTest/AddTask.js)
-  content/tests/SimpleTest/AsyncUtilsContent.js (tests/SimpleTest/AsyncUtilsContent.js)
-  content/tests/SimpleTest/LogController.js (tests/SimpleTest/LogController.js)
-  content/tests/SimpleTest/MemoryStats.js (tests/SimpleTest/MemoryStats.js)
-  content/tests/SimpleTest/MozillaLogger.js (../specialpowers/content/MozillaLogger.js)
-  content/tests/SimpleTest/specialpowers.js (../specialpowers/content/specialpowers.js)
-  content/tests/SimpleTest/SpecialPowersObserverAPI.js (../specialpowers/content/SpecialPowersObserverAPI.js)
-  content/tests/SimpleTest/specialpowersAPI.js (../specialpowers/content/specialpowersAPI.js)
-  content/tests/SimpleTest/setup.js (tests/SimpleTest/setup.js)
-  content/tests/SimpleTest/SimpleTest.js (tests/SimpleTest/SimpleTest.js)
-  content/tests/SimpleTest/StructuredLog.jsm (../modules/StructuredLog.jsm)
-  content/tests/SimpleTest/test.css (tests/SimpleTest/test.css)
-  content/tests/SimpleTest/TestRunner.js (tests/SimpleTest/TestRunner.js)
-  content/tests/SimpleTest/iframe-between-tests.html (tests/SimpleTest/iframe-between-tests.html)
-  content/tests/SimpleTest/WindowSnapshot.js (tests/SimpleTest/WindowSnapshot.js)
-  content/tests/SimpleTest/MockObjects.js (tests/SimpleTest/MockObjects.js)
-  content/tests/SimpleTest/NativeKeyCodes.js (tests/SimpleTest/NativeKeyCodes.js)
-  content/tests/SimpleTest/paint_listener.js (tests/SimpleTest/paint_listener.js)
-  content/tests/SimpleTest/docshell_helpers.js (../../docshell/test/chrome/docshell_helpers.js)
-  content/tests/BrowserTestUtils/content-task.js (BrowserTestUtils/content/content-task.js)
-  content/tests/BrowserTestUtils/content-about-page-utils.js (BrowserTestUtils/content/content-about-page-utils.js)
-  content/tests/BrowserTestUtils/content-utils.js (BrowserTestUtils/content/content-utils.js)
-
new file mode 100644
--- /dev/null
+++ b/testing/mochitest/manifest.json
@@ -0,0 +1,22 @@
+{
+  "manifest_version": 2,
+  "name": "Mochitest",
+  "version": "2.0",
+
+  "applications": {
+    "gecko": {
+      "id": "mochikit@mozilla.org"
+    }
+  },
+
+  "experiment_apis": {
+    "mochikit": {
+      "schema": "schema.json",
+      "parent": {
+        "scopes": ["addon_parent"],
+        "script": "api.js",
+        "events": ["startup"]
+      }
+    }
+  }
+}
--- a/testing/mochitest/moz.build
+++ b/testing/mochitest/moz.build
@@ -8,23 +8,77 @@ DIRS += [
     'manifests',
     'tests',
     'ssltunnel',
     'BrowserTestUtils',
 ]
 
 XPI_NAME = 'mochijar'
 
-JAR_MANIFESTS += ['jar.mn']
-
 USE_EXTENSION_MANIFEST = True
 
-FINAL_TARGET_PP_FILES += ['install.rdf']
+FINAL_TARGET_FILES += [
+    'api.js',
+    'manifest.json',
+    'schema.json',
+]
+
+FINAL_TARGET_FILES.content += [
+    'browser-harness.xul',
+    'browser-test.js',
+    'chrome-harness.js',
+    'chunkifyTests.js',
+    'harness.xul',
+    'manifestLibrary.js',
+    'mochitest-e10s-utils.js',
+    'nested_setup.js',
+    'redirect.html',
+    'server.js',
+    'shutdown-leaks-collector.js',
+    'ShutdownLeaksCollector.jsm',
+]
+
+FINAL_TARGET_FILES.content.dynamic += [
+    'dynamic/getMyDirectory.sjs',
+]
+
+FINAL_TARGET_FILES.content.static += [
+    'static/harness.css',
+]
 
-FINAL_TARGET_FILES += ['bootstrap.js']
+FINAL_TARGET_FILES.content.tests.SimpleTest += [
+    '../../docshell/test/chrome/docshell_helpers.js',
+    '../modules/StructuredLog.jsm',
+    '../specialpowers/content/MozillaLogger.js',
+    '../specialpowers/content/specialpowers.js',
+    '../specialpowers/content/specialpowersAPI.js',
+    '../specialpowers/content/SpecialPowersObserverAPI.js',
+    'tests/SimpleTest/AddTask.js',
+    'tests/SimpleTest/AsyncUtilsContent.js',
+    'tests/SimpleTest/ChromePowers.js',
+    'tests/SimpleTest/EventUtils.js',
+    'tests/SimpleTest/ExtensionTestUtils.js',
+    'tests/SimpleTest/iframe-between-tests.html',
+    'tests/SimpleTest/LogController.js',
+    'tests/SimpleTest/MemoryStats.js',
+    'tests/SimpleTest/MockObjects.js',
+    'tests/SimpleTest/NativeKeyCodes.js',
+    'tests/SimpleTest/paint_listener.js',
+    'tests/SimpleTest/setup.js',
+    'tests/SimpleTest/SimpleTest.js',
+    'tests/SimpleTest/test.css',
+    'tests/SimpleTest/TestRunner.js',
+    'tests/SimpleTest/WindowSnapshot.js',
+]
+
+FINAL_TARGET_FILES.content.tests.BrowserTestUtils += [
+    'BrowserTestUtils/content/content-about-page-utils.js',
+    'BrowserTestUtils/content/content-task.js',
+    'BrowserTestUtils/content/content-utils.js',
+]
 
 MOCHITEST_MANIFESTS += [
     'baselinecoverage/plain/mochitest.ini',
     'tests/MochiKit-1.4.2/tests/mochitest.ini',
 ]
 
 MOCHITEST_CHROME_MANIFESTS += [
     'baselinecoverage/chrome/chrome.ini',
--- a/testing/mochitest/redirect.html
+++ b/testing/mochitest/redirect.html
@@ -20,18 +20,19 @@
       redirect("chrome://mochikit/content/harness.xul");
     }
 
     function onLoad() {
       // Wait for MozAfterPaint, since the listener in browser-test.js is not
       // added until then.
       window.addEventListener("MozAfterPaint", function() {
         setTimeout(redirectToHarness, 0);
-        // In case the listener was not ready, try again after a few seconds.
-        setTimeout(redirectToHarness, 5000);
+
+        // In case the listener is not ready, re-try periodically
+        setInterval(redirectToHarness, 5000);
       }, {once: true});
 
     }
   </script>
 </head>
 
 <body onload="onLoad();">
 redirecting...
new file mode 100644
--- /dev/null
+++ b/testing/mochitest/schema.json
@@ -0,0 +1,1 @@
+[]
--- a/testing/web-platform/meta/MANIFEST.json
+++ b/testing/web-platform/meta/MANIFEST.json
@@ -13802,16 +13802,22 @@
     ]
    ],
    "pointerevents/pointerlock/pointerevent_pointerlock_supercedes_capture-manual.html": [
     [
      "/pointerevents/pointerlock/pointerevent_pointerlock_supercedes_capture-manual.html",
      {}
     ]
    ],
+   "pointerlock/mouse_buttons_back_forward-manual.html": [
+    [
+     "/pointerlock/mouse_buttons_back_forward-manual.html",
+     {}
+    ]
+   ],
    "pointerlock/movementX_Y_basic-manual.html": [
     [
      "/pointerlock/movementX_Y_basic-manual.html",
      {}
     ]
    ],
    "pointerlock/movementX_Y_no-jumps-manual.html": [
     [
@@ -120766,16 +120772,28 @@
       [
        "/css/css-grid/reference/display-inline-grid-ref.html",
        "=="
       ]
      ],
      {}
     ]
    ],
+   "css/css-grid/grid-model/grid-container-ignores-first-letter-002.html": [
+    [
+     "/css/css-grid/grid-model/grid-container-ignores-first-letter-002.html",
+     [
+      [
+       "/css/css-grid/grid-model/grid-container-ignores-first-letter-002-ref.html",
+       "=="
+      ]
+     ],
+     {}
+    ]
+   ],
    "css/css-grid/grid-model/grid-display-grid-001.html": [
     [
      "/css/css-grid/grid-model/grid-display-grid-001.html",
      [
       [
        "/css/reference/ref-filled-green-100px-square.xht",
        "=="
       ]
@@ -165026,16 +165044,28 @@
       [
        "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-rtl-004-ref.html",
        "=="
       ]
      ],
      {}
     ]
    ],
+   "css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-safe-001.html": [
+    [
+     "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-safe-001.html",
+     [
+      [
+       "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-safe-001-ref.html",
+       "=="
+      ]
+     ],
+     {}
+    ]
+   ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-vertWM-001.html": [
     [
      "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-vertWM-001.html",
      [
       [
        "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-vertWM-001-ref.html",
        "=="
       ]
@@ -165374,16 +165404,28 @@
       [
        "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-rtl-004-ref.html",
        "=="
       ]
      ],
      {}
     ]
    ],
+   "css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-safe-001.html": [
+    [
+     "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-safe-001.html",
+     [
+      [
+       "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-safe-001-ref.html",
+       "=="
+      ]
+     ],
+     {}
+    ]
+   ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-vertWM-001.html": [
     [
      "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-vertWM-001.html",
      [
       [
        "/css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-vertWM-001-ref.html",
        "=="
       ]
@@ -166802,16 +166844,40 @@
       [
        "/css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-button-001-ref.html",
        "=="
       ]
      ],
      {}
     ]
    ],
+   "css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-fieldset-001.html": [
+    [
+     "/css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-fieldset-001.html",
+     [
+      [
+       "/css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-fieldset-001-ref.html",
+       "=="
+      ]
+     ],
+     {}
+    ]
+   ],
+   "css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-fieldset-002.html": [
+    [
+     "/css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-fieldset-002.html",
+     [
+      [
+       "/css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-fieldset-002-ref.html",
+       "=="
+      ]
+     ],
+     {}
+    ]
+   ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-flex-001.html": [
     [
      "/css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-flex-001.html",
      [
       [
        "/css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-flex-001-ref.html",
        "=="
       ]
@@ -189528,102 +189594,42 @@
    "service-workers/stub-5.2-cross-origin-resources.html": [
     [
      "/service-workers/stub-5.2-cross-origin-resources.html",
      {}
     ]
    ]
   },
   "support": {
-   "./.codecov.yml": [
-    [
-     {}
-    ]
-   ],
-   "./.gitignore": [
-    [
-     {}
-    ]
-   ],
-   "./.gitmodules": [
-    [
-     {}
-    ]
-   ],
-   "./.pyup.yml": [
-    [
-     {}
-    ]
-   ],
-   "./.taskcluster.yml": [
-    [
-     {}
-    ]
-   ],
-   "./.travis.yml": [
-    [
-     {}
-    ]
-   ],
-   "./CODEOWNERS": [
-    [
-     {}
-    ]
-   ],
-   "./CONTRIBUTING.md": [
-    [
-     {}
-    ]
-   ],
-   "./LICENSE": [
-    [
-     {}
-    ]
-   ],
-   "./LICENSE.md": [
-    [
-     {}
-    ]
-   ],
-   "./README.md": [
-    [
-     {}
-    ]
-   ],
-   "./check_stability.ini": [
-    [
-     {}
-    ]
-   ],
-   "./lint.whitelist": [
-    [
-     {}
-    ]
-   ],
-   "./serve.py": [
-    [
-     {}
-    ]
-   ],
-   "./server-side.md": [
-    [
-     {}
-    ]
-   ],
-   "./update-built-tests.sh": [
-    [
-     {}
-    ]
-   ],
-   "./wpt": [
-    [
-     {}
-    ]
-   ],
-   "./wpt.py": [
+   ".codecov.yml": [
+    [
+     {}
+    ]
+   ],
+   ".gitignore": [
+    [
+     {}
+    ]
+   ],
+   ".gitmodules": [
+    [
+     {}
+    ]
+   ],
+   ".pyup.yml": [
+    [
+     {}
+    ]
+   ],
+   ".taskcluster.yml": [
+    [
+     {}
+    ]
+   ],
+   ".travis.yml": [
     [
      {}
     ]
    ],
    ".well-known/README.md": [
     [
      {}
     ]
@@ -190638,16 +190644,26 @@
      {}
     ]
    ],
    "BackgroundSync/META.yml": [
     [
      {}
     ]
    ],
+   "CODEOWNERS": [
+    [
+     {}
+    ]
+   ],
+   "CONTRIBUTING.md": [
+    [
+     {}
+    ]
+   ],
    "FileAPI/BlobURL/support/file_test2.txt": [
     [
      {}
     ]
    ],
    "FileAPI/FileReader/support/file_test1.txt": [
     [
      {}
@@ -190768,16 +190784,31 @@
      {}
     ]
    ],
    "IndexedDB/support.js": [
     [
      {}
     ]
    ],
+   "LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "LICENSE.md": [
+    [
+     {}
+    ]
+   ],
+   "README.md": [
+    [
+     {}
+    ]
+   ],
    "WebCryptoAPI/META.yml": [
     [
      {}
     ]
    ],
    "WebCryptoAPI/README.md": [
     [
      {}
@@ -194373,16 +194404,21 @@
      {}
     ]
    ],
    "budget-api/META.yml": [
     [
      {}
     ]
    ],
+   "check_stability.ini": [
+    [
+     {}
+    ]
+   ],
    "clear-site-data/META.yml": [
     [
      {}
     ]
    ],
    "clear-site-data/support/echo-clear-site-data.py": [
     [
      {}
@@ -252603,16 +252639,21 @@
      {}
     ]
    ],
    "css/css-grid/grid-items/support/grid.css": [
     [
      {}
     ]
    ],
+   "css/css-grid/grid-model/grid-container-ignores-first-letter-002-ref.html": [
+    [
+     {}
+    ]
+   ],
    "css/css-grid/grid-model/support/grid.css": [
     [
      {}
     ]
    ],
    "css/css-grid/reference/display-grid-ref.html": [
     [
      {}
@@ -268788,16 +268829,21 @@
      {}
     ]
    ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-rtl-004-ref.html": [
     [
      {}
     ]
    ],
+   "css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-safe-001-ref.html": [
+    [
+     {}
+    ]
+   ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-vertWM-001-ref.html": [
     [
      {}
     ]
    ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/align3/flex-abspos-staticpos-align-self-vertWM-002-ref.html": [
     [
      {}
@@ -268933,16 +268979,21 @@
      {}
     ]
    ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-rtl-004-ref.html": [
     [
      {}
     ]
    ],
+   "css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-safe-001-ref.html": [
+    [
+     {}
+    ]
+   ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-vertWM-001-ref.html": [
     [
      {}
     ]
    ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/align3/grid-abspos-staticpos-align-self-vertWM-002-ref.html": [
     [
      {}
@@ -269368,16 +269419,26 @@
      {}
     ]
    ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-button-001-ref.html": [
     [
      {}
     ]
    ],
+   "css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-fieldset-001-ref.html": [
+    [
+     {}
+    ]
+   ],
+   "css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-fieldset-002-ref.html": [
+    [
+     {}
+    ]
+   ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-flex-001-ref.html": [
     [
      {}
     ]
    ],
    "css/vendor-imports/mozilla/mozilla-central-reftests/contain/contain-size-inline-block-001-ref.html": [
     [
      {}
@@ -275923,16 +275984,21 @@
      {}
     ]
    ],
    "fetch/api/resources/redirect.py": [
     [
      {}
     ]
    ],
+   "fetch/api/resources/sandboxed-iframe.html": [
+    [
+     {}
+    ]
+   ],
    "fetch/api/resources/script-with-header.py": [
     [
      {}
     ]
    ],
    "fetch/api/resources/stash-put.py": [
     [
      {}
@@ -287753,16 +287819,21 @@
      {}
     ]
    ],
    "interfaces/SRI.idl": [
     [
      {}
     ]
    ],
+   "interfaces/SVG.idl": [
+    [
+     {}
+    ]
+   ],
    "interfaces/WebCryptoAPI.idl": [
     [
      {}
     ]
    ],
    "interfaces/WebIDL.idl": [
     [
      {}
@@ -287883,16 +287954,21 @@
      {}
     ]
    ],
    "interfaces/css-paint-api.idl": [
     [
      {}
     ]
    ],
+   "interfaces/css-properties-values-api.idl": [
+    [
+     {}
+    ]
+   ],
    "interfaces/css-regions.idl": [
     [
      {}
     ]
    ],
    "interfaces/css-transitions.idl": [
     [
      {}
@@ -288283,16 +288359,21 @@
      {}
     ]
    ],
    "interfaces/webdriver.idl": [
     [
      {}
     ]
    ],
+   "interfaces/webgl1.idl": [
+    [
+     {}
+    ]
+   ],
    "interfaces/webrtc-pc.idl": [
     [
      {}
     ]
    ],
    "interfaces/webusb.idl": [
     [
      {}
@@ -288403,16 +288484,21 @@
      {}
     ]
    ],
    "lifecycle/resources/window.html": [
     [
      {}
     ]
    ],
+   "lint.whitelist": [
+    [
+     {}
+    ]
+   ],
    "longtask-timing/META.yml": [
     [
      {}
     ]
    ],
    "longtask-timing/resources/makelongtask.js": [
     [
      {}
@@ -293493,16 +293579,2276 @@
      {}
     ]
    ],
    "resource-timing/test_resource_timing.js": [
     [
      {}
     ]
    ],
+   "resources/.gitignore": [
+    [
+     {}
+    ]
+   ],
+   "resources/.htaccess": [
+    [
+     {}
+    ]
+   ],
+   "resources/LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "resources/META.yml": [
+    [
+     {}
+    ]
+   ],
+   "resources/check-layout-th.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/README.md": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/chooser_service.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/chooser_service.mojom.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/device.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/device.mojom.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/device_manager.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/device_manager.mojom.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/fake_bluetooth.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/fake_bluetooth.mojom.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/fake_bluetooth_chooser.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/fake_bluetooth_chooser.mojom.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/generic_sensor_mocks.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/generic_sensor_mocks.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/mojo_bindings.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/mojo_bindings.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/mojo_layouttest_test.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/mojo_layouttest_test.mojom.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/sensor.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/sensor_provider.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/string16.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/string16.mojom.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/uuid.mojom.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/uuid.mojom.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/web-bluetooth-test.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/web-bluetooth-test.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/webusb-test.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/webusb-test.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/webxr-test.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/chromium/webxr-test.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/idlharness.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/idlharness.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/readme.md": [
+    [
+     {}
+    ]
+   ],
+   "resources/sriharness.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/README.md": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/conftest.py": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/harness.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/idl-helper.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/add_cleanup.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/add_cleanup_count.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/add_cleanup_err.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/add_cleanup_err_multi.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/api-tests-1.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/api-tests-2.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/api-tests-3.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/force_timeout.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/generate-callback.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/idlharness/IdlDictionary/test_partial_interface_of.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/idlharness/IdlInterface/test_immutable_prototype.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/idlharness/IdlInterface/test_partial_interface_of.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/idlharness/IdlInterface/test_primary_interface_of.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/idlharness/IdlInterface/test_to_json_operation.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/idlharness/IdlNamespace/test_attribute.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/idlharness/IdlNamespace/test_operation.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/idlharness/IdlNamespace/test_partial_namespace.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/iframe-callback.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/iframe-consolidate-errors.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/iframe-consolidate-tests.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/iframe-msg.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/order.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/promise-async.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/promise.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/single-page-test-fail.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/single-page-test-no-assertions.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/single-page-test-no-body.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/single-page-test-pass.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/uncaught-exception-handle.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/uncaught-exception-ignore.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/worker-dedicated-uncaught-single.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/worker-dedicated.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/worker-error.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/worker-service.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/worker-shared.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/worker-uncaught-single.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/functional/worker.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlArray/is_json_type.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlDictionary/get_inheritance_stack.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlDictionary/test_partial_dictionary.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlInterface/default_to_json_operation.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlInterface/get_inheritance_stack.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlInterface/has_default_to_json_regular_operation.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlInterface/has_to_json_regular_operation.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlInterface/test_primary_interface_of_undefined.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlInterface/traverse_inherited_and_consequential_interfaces.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/IdlInterfaceMember/is_to_json_regular_operation.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/META.yml": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tests/unit/basic.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/tox.ini": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/variants.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/test/wptserver.py": [
+    [
+     {}
+    ]
+   ],
+   "resources/testdriver-vendor.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/testdriver-vendor.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/testdriver.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/testdriver.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/testharness.css.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/testharness.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/testharness.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/testharnessreport.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/testharnessreport.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/.gitignore": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/.travis.yml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/CHANGELOG.md": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/README.md": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/checker/index.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/coverage.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/index.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/lib/webidl2.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/lib/webidl2.js.headers": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/lib/writer.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/package-lock.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/package.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/array.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/caller.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/dict-required-default.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/duplicate.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/enum-empty.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/enum-wo-comma.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/enum.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/exception.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/extattr-empty-ids.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/id-underscored-number.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/implements_and_includes_ws.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/iterator.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/maplike-1type.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/module.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/namespace-readwrite.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/no-semicolon-callback.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/no-semicolon.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/nonnullableany.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/nonnullableobjects.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/promise-nullable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/promise-with-extended-attribute.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/raises.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/readonly-iterable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/record-key-with-extended-attribute.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/record-key.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/record-single.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/scopedname.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/sequenceAsAttribute.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/setlike-2types.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/setter-creator.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/spaced-negative-infinity.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/spaced-variadic.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/special-omittable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/stray-slash.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/stringconstants.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/typedef-nested.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/union-dangling-or.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/union-one.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/union-zero.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/idl/unknown-generic.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/array.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/caller.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/dict-required-default.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/duplicate.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/enum-empty.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/enum-wo-comma.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/enum.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/exception.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/extattr-empty-ids.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/id-underscored-number.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/implements_and_includes_ws.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/iterator.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/maplike-1type.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/module.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/namespace-readwrite.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/no-semicolon-callback.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/no-semicolon.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/nonnullableany.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/nonnullableobjects.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/promise-nullable.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/promise-with-extended-attribute.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/raises.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/readonly-iterable.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/record-key-with-extended-attribute.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/record-key.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/record-single.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/scopedname.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/sequenceAsAttribute.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/setlike-2types.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/setter-creator.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/spaced-negative-infinity.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/spaced-variadic.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/special-omittable.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/stray-slash.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/stringconstants.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/typedef-nested.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/union-dangling-or.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/union-one.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/union-zero.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/invalid/json/unknown-generic.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/mocha.opts": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/allowany.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/attributes.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/callback.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/constants.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/constructor.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/dictionary-inherits.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/dictionary.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/documentation-dos.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/documentation.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/enum.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/equivalent-decl.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/extended-attributes.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/generic.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/getter-setter.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/identifier-qualified-names.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/implements.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/indexed-properties.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/inherits-getter.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/interface-inherits.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/iterable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/legacyiterable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/maplike.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/mixin.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/namedconstructor.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/namespace.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/nointerfaceobject.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/nullable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/nullableobjects.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/operation-optional-arg.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/overloading.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/overridebuiltins.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/partial-interface.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/primitives.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/promise-void.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/prototyperoot.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/putforwards.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/record.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/reg-operations.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/replaceable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/sequence.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/setlike.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/static.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/stringifier-attribute.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/stringifier-custom.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/stringifier.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/treatasnull.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/treatasundefined.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/typedef-union.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/typedef.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/typesuffixes.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/uniontype.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/idl/variadic-operations.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/allowany.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/attributes.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/callback.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/constants.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/constructor.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/dictionary-inherits.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/dictionary.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/documentation-dos.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/documentation.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/enum.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/equivalent-decl.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/exception-inheritance.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/extended-attributes.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/generic.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/getter-setter.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/identifier-qualified-names.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/implements.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/indexed-properties.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/inherits-getter.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/interface-inherits.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/iterable.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/iterator.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/legacyiterable.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/maplike.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/mixin.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/namedconstructor.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/namespace.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/nointerfaceobject.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/nullable.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/nullableobjects.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/operation-optional-arg.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/overloading.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/overridebuiltins.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/partial-interface.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/primitives.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/promise-void.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/prototyperoot.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/putforwards.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/record.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/reg-operations.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/replaceable.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/sequence.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/setlike.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/static.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/stringifier-attribute.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/stringifier-custom.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/stringifier.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/treatasnull.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/treatasundefined.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/typedef-union.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/typedef.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/typesuffixes.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/uniontype.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/syntax/json/variadic-operations.json": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/util/acquire.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/util/collect.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/web/make-web-tests.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/web/run-tests.js": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/.gitignore": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/Makefile": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/README.md": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/doc/htmltodtd.xsl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/doc/widlproc.html": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/examples/Makefile": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/examples/README": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/examples/bondi.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/examples/filesystem.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/examples/spectowidl.xsl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/examples/widlhtml.css": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/comment.c": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/comment.h": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/entities.h": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/lex.c": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/lex.h": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/main.c": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/misc.c": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/misc.h": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/node.c": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/node.h": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/os.h": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/parse.c": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/parse.h": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/process.c": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/process.h": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/src/widlprocxmltohtml.xsl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/Makefile": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/error/enum.txt": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/error/module.txt": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/error/nonnullableany.txt": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/error/nonnullableobjects.txt": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/error/scopedname.txt": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/error/sequenceAsAttribute.txt": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/error/stringconstants.idl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/idl/enum.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/idl/module.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/idl/nonnullableany.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/idl/nonnullableobjects.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/idl/raises.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/idl/scopedname.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/idl/sequenceAsAttribute.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/idl/special-omittable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/invalid/idl/stringconstants.idl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/allowany.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/array.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/attributes.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/callback.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/caller.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/constants.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/constructor.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/dictionary-inherits.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/dictionary.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/documentation-dos.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/documentation.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/enum.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/equivalent-decl.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/exception-inheritance.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/exception.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/getter-setter.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/identifier-qualified-names.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/implements.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/indexed-properties.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/inherits-getter.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/interface-inherits.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/iterator.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/namedconstructor.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/nointerfaceobject.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/nullable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/nullableobjects.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/operation-optional-arg.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/overloading.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/overridebuiltins.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/partial-interface.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/primitives.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/prototyperoot.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/putforwards.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/reg-operations.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/replaceable.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/sequence.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/serializer.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/static.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/stringifier-attribute.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/stringifier-custom.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/stringifier.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/treatasnull.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/treatasundefined.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/typedef.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/typesuffixes.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/uniontype.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/idl/variadic-operations.widl": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/allowany.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/array.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/attributes.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/callback.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/caller.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/constants.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/constructor.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/dictionary-inherits.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/dictionary.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/documentation-dos.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/documentation.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/enum.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/equivalent-decl.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/exception-inheritance.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/exception.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/getter-setter.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/identifier-qualified-names.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/implements.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/indexed-properties.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/inherits-getter.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/interface-inherits.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/iterator.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/module.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/namedconstructor.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/namespaceobject.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/nointerfaceobject.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/nullable.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/nullableobjects.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/operation-optional-arg.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/overloading.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/overridebuiltins.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/partial-interface.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/primitives.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/prototyperoot.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/putforwards.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/reg-operations.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/replaceable.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/sequence.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/serializer.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/special-omittable.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/static.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/stringifier-attribute.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/stringifier-custom.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/stringifier.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/treatasnull.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/treatasundefined.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/typedef.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/typesuffixes.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/uniontype.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/widlproc/test/valid/xml/variadic-operations.widlprocxml": [
+    [
+     {}
+    ]
+   ],
+   "resources/webidl2/test/writer.js": [
+    [
+     {}
+    ]
+   ],
    "screen-orientation/META.yml": [
     [
      {}
     ]
    ],
    "screen-orientation/resources/iframe-listen-orientation-change.html": [
     [
      {}
@@ -293603,16 +295949,26 @@
      {}
     ]
    ],
    "selection/test-iframe.html": [
     [
      {}
     ]
    ],
+   "serve.py": [
+    [
+     {}
+    ]
+   ],
+   "server-side.md": [
+    [
+     {}
+    ]
+   ],
    "server-timing/META.yml": [
     [
      {}
     ]
    ],
    "server-timing/resources/blue.png": [
     [
      {}
@@ -297313,16 +299669,6536 @@
      {}
     ]
    ],
    "svg/types/scripted/resources/SVGLengthList-helper.js": [
     [
      {}
     ]
    ],
+   "testharness_runner.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/.gitattributes": [
+    [
+     {}
+    ]
+   ],
+   "tools/.gitignore": [
+    [
+     {}
+    ]
+   ],
+   "tools/.gitmodules": [
+    [
+     {}
+    ]
+   ],
+   "tools/META.yml": [
+    [
+     {}
+    ]
+   ],
+   "tools/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/appveyor.yml": [
+    [
+     {}
+    ]
+   ],
+   "tools/certs/README.md": [
+    [
+     {}
+    ]
+   ],
+   "tools/certs/cacert.key": [
+    [
+     {}
+    ]
+   ],
+   "tools/certs/cacert.pem": [
+    [
+     {}
+    ]
+   ],
+   "tools/certs/web-platform.test.key": [
+    [
+     {}
+    ]
+   ],
+   "tools/certs/web-platform.test.pem": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/before_install.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/check_stability.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/ci_built_diff.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/ci_lint.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/ci_manifest.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/ci_resources_unittest.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/ci_stability.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/ci_taskcluster.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/ci_tools_unittest.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/ci_wpt.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/ci_wptrunner_infrastructure.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/commands.json": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/install.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/jobs.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/lib.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/make_hosts_file.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/run.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/tag_master.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/ci/tests/test_jobs.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/conftest.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/docker/.bashrc": [
+    [
+     {}
+    ]
+   ],
+   "tools/docker/Dockerfile": [
+    [
+     {}
+    ]
+   ],
+   "tools/docker/start.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/flake8.ini": [
+    [
+     {}
+    ]
+   ],
+   "tools/gitignore/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/gitignore/gitignore.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/gitignore/tests/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/gitignore/tests/test_gitignore.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/AUTHORS.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/encoding/chardet/test_big5.txt": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/encoding/test-yahoo-jp.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/encoding/tests1.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/encoding/tests2.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/sanitizer/tests1.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/serializer/core.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/serializer/injectmeta.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/serializer/optionaltags.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/serializer/options.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/serializer/whitespace.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/sniffer/htmlOrFeed.json": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/README.md": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/contentModelFlags.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/domjs.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/entities.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/escapeFlag.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/namedEntities.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/numericEntities.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/pendingSpecChanges.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/test1.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/test2.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/test3.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/test4.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/unicodeChars.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/unicodeCharsProblematic.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tokenizer/xmlViolation.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/README.md": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/adoption01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/adoption02.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/comments01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/doctype01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/domjs-unsafe.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/entities01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/entities02.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/html5test-com.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/inbody01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/isindex.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/main-element.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/pending-spec-changes-plain-text-unsafe.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/pending-spec-changes.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/plain-text-unsafe.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/ruby.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/scriptdata01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/scripted/adoption01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/scripted/ark.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/scripted/webkit01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tables01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/template.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests1.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests10.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests11.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests12.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests14.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests15.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests16.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests17.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests18.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests19.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests2.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests20.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests21.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests22.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests23.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests24.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests25.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests26.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests3.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests4.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests5.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests6.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests7.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests8.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests9.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tests_innerHTML_1.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/tricky01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/webkit01.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/tree-construction/webkit02.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/attributes.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/base-href-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/base-target-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/blockquote-cite-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/classattribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/contenteditableattribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/contextmenuattribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/dirattribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/draggableattribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/html-xmlns-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/idattribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/inputattributes.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/irrelevantattribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/langattribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/li-value-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/link-href-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/link-hreflang-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/link-rel-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/ol-start-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/starttags.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/style-scoped-attribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/html5lib/html5lib/tests/testdata/validator/tabindexattribute.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/commands.json": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/fnmatch.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/lint.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/base.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/broken.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/broken_ignored.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/a-ref.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/match/a-ref.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/match/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/match/support/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/match/support/tools/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/match/tools/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/not-match/a-ref.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/not-match/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/not-match/support/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/not-match/tools/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/relative-testharness-interact.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/relative-testharness.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/selectors/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/support/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/support/tools/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/css/css-unique/tools/a.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/dependency.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/lint.whitelist": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/okay.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/ref/about_blank-ref.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/ref/absolute.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/ref/existent_relative-ref.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/ref/existent_relative.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/ref/existent_root_relative.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/ref/non_existent_relative.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/ref/non_existent_root_relative.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/ref/same_file_empty.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/ref/same_file_path.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/dummy/tests/relative-testharness-manual.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/test_file_lints.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/test_lint.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/lint/tests/test_path_lints.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/localpaths.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/XMLParser.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/catalog/xhtml.dtd": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/commands.json": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/download.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/item.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/log.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/manifest.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/sourcefile.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/tests/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/tests/test_XMLParser.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/tests/test_manifest.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/tests/test_sourcefile.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/update.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/utils.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/manifest/vcs.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pytest.ini": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/CONTRIBUTING": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/MANIFEST.in": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/README": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/README.md": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/abort_handshake_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/abort_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/arraybuffer_benchmark.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/bench_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/benchmark.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/benchmark.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/benchmark_helper_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/close_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/console.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/cookie_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/echo_client.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/echo_noext_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/echo_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/eventsource.cgi": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/eventsource.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/fetch_benchmark.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/fetch_benchmark.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/fetch_performance_test_iframe.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/handler_map.txt": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/hsts_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/internal_error_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/origin_check_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/performance_test_iframe.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/performance_test_iframe.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/pywebsocket.conf": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/special_headers.cgi": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/util.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/util_main.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/util_worker.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/xhr_benchmark.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/xhr_benchmark.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/xhr_event_logger.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/example/xhr_performance_test_iframe.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/_stream_base.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/_stream_hixie75.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/_stream_hybi.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/common.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/dispatch.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/extensions.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/fast_masking.i": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/handshake/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/handshake/_base.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/handshake/hybi.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/handshake/hybi00.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/headerparserhandler.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/http_header_util.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/memorizingfile.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/msgutil.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/mux.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/standalone.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/stream.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/util.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/mod_pywebsocket/xhr_benchmark_handler.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/setup.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/cert/cacert.pem": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/cert/cert.pem": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/cert/client_cert.p12": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/cert/key.pem": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/client_for_testing.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/endtoend_with_external_server.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/mock.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/mux_client_for_testing.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/run_all.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/set_sys_path.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_dispatch.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_endtoend.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_extensions.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_handshake.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_handshake_hybi.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_handshake_hybi00.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_http_header_util.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_memorizingfile.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_mock.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_msgutil.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_mux.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_stream.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_stream_hixie75.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/test_util.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/README": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/handlers/abort_by_user_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/handlers/blank_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/handlers/origin_check_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/handlers/sub/exception_in_transfer_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/handlers/sub/no_wsh_at_the_end.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/handlers/sub/non_callable_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/handlers/sub/plain_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/handlers/sub/wrong_handshake_sig_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/handlers/sub/wrong_transfer_sig_wsh.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/pywebsocket/test/testdata/hello.pl": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/css/bootstrap-theme.min.css": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/css/bootstrap.min.css": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/fonts/glyphicons-halflings-regular.eot": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/fonts/glyphicons-halflings-regular.svg": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/fonts/glyphicons-halflings-regular.ttf": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/fonts/glyphicons-halflings-regular.woff": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/index.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/logo.svg": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/report.css": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/report.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/runner.css": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/runner.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/runner/update_manifest.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/scripts/id2path.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/scripts/id2path.json": [
+    [
+     {}
+    ]
+   ],
+   "tools/scripts/manifest.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/scripts/package.json": [
+    [
+     {}
+    ]
+   ],
+   "tools/scripts/toc.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/scripts/update-directory-structure.js": [
+    [
+     {}
+    ]
+   ],
+   "tools/serve/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/serve/commands.json": [
+    [
+     {}
+    ]
+   ],
+   "tools/serve/serve.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/serve/test_serve.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/.gitignore": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/.travis.yml": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/CONTRIBUTING.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/MANIFEST.in": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/Makefile": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/README.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/appveyor.yml": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/atomicwrites/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/docs/Makefile": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/docs/conf.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/docs/index.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/docs/make.bat": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/setup.cfg": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/setup.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/atomicwrites/tox.ini": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/.coveragerc": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/.github/CODE_OF_CONDUCT.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/.github/CONTRIBUTING.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/.github/PULL_REQUEST_TEMPLATE.md": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/.gitignore": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/.readthedocs.yml": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/.travis.yml": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/AUTHORS.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/CHANGELOG.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/MANIFEST.in": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/README.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/.gitignore": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/178.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/290.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/300.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/311.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/321.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/322.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/323.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/326.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/331.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/332.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/334.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/336.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/339.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/343.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/349.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/356.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/363.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/369.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/370.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/95.change.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/changelog.d/towncrier_template.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/conftest.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/Makefile": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/_static/attrs_logo.png": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/_static/attrs_logo.svg": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/api.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/backward-compatibility.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/changelog.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/conf.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/contributing.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/docutils.conf": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/examples.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/extending.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/glossary.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/hashing.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/how-does-it-work.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/index.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/init.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/license.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/overview.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/docs/why.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/pyproject.toml": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/setup.cfg": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/setup.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/src/attr/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/src/attr/_compat.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/src/attr/_config.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/src/attr/_funcs.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/src/attr/_make.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/src/attr/converters.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/src/attr/exceptions.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/src/attr/filters.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/src/attr/validators.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/strategies.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_annotations.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_config.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_converters.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_dark_magic.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_dunders.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_filters.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_funcs.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_init_subclass.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_make.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_slots.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/test_validators.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tests/utils.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/attrs/tox.ini": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/.travis.yml": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/CHANGELOG": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/MANIFEST.in": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/Makefile": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/README.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/docs/Makefile": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/docs/_templates/page.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/docs/conf.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/docs/index.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/funcsigs/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/funcsigs/odict.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/funcsigs/version.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/requirements/development.txt": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/requirements/production.txt": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/setup.cfg": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/setup.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/tests/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/tests/test_formatannotation.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/tests/test_funcsigs.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/funcsigs/tests/test_inspect.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/.appveyor.yml": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/.coveragerc": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/.gitignore": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/.gitmodules": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/.prospector.yaml": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/.pylintrc": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/.pytest.expect": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/.travis.yml": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/AUTHORS.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/CHANGES.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/CONTRIBUTING.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/LICENSE": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/MANIFEST.in": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/README.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/debug-info.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/Makefile": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/changes.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/conf.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/html5lib.filters.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/html5lib.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/html5lib.treeadapters.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/html5lib.treebuilders.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/html5lib.treewalkers.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/index.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/license.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/make.bat": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/modules.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/doc/movingparts.rst": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/flake8-run.sh": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/_ihatexml.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/_inputstream.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/_tokenizer.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/_trie/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/_trie/_base.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/_trie/datrie.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/_trie/py.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/_utils.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/constants.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/filters/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/filters/alphabeticalattributes.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/filters/base.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/filters/inject_meta_charset.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/filters/lint.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/filters/optionaltags.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/filters/sanitizer.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/filters/whitespace.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/html5parser.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/serializer.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/conftest.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/sanitizer-testdata/tests1.dat": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/sanitizer.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/serializer-testdata/core.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/serializer-testdata/injectmeta.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/serializer-testdata/optionaltags.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/serializer-testdata/options.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/serializer-testdata/whitespace.test": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/support.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_alphabeticalattributes.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_encoding.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_meta.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_optionaltags_filter.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_parser2.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_sanitizer.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_serializer.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_stream.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_treeadapters.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_treewalkers.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/test_whitespace_filter.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/tokenizer.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/tokenizertotree.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/tree_construction.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/us-ascii.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/tests/utf-8-bom.html": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treeadapters/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treeadapters/genshi.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treeadapters/sax.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treebuilders/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treebuilders/base.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treebuilders/dom.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treebuilders/etree.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treebuilders/etree_lxml.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treewalkers/__init__.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treewalkers/base.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treewalkers/dom.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treewalkers/etree.py": [
+    [
+     {}
+    ]
+   ],
+   "tools/third_party/html5lib/html5lib/treewalkers/etree_lxml.py": [