Add m-esr52 at 52.6.0

48 files changed, 32617 insertions, 0 deletions

diff --git a/js/xpconnect/src/BackstagePass.h b/js/xpconnect/src/BackstagePass.h
new file mode 100644
index 000000000..be7d15cdf
--- /dev/null
+++ b/js/xpconnect/src/BackstagePass.h
@@ -0,0 +1,58 @@
+/* -*- 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 BackstagePass_h__
+#define BackstagePass_h__
+
+#include "nsISupports.h"
+#include "nsWeakReference.h"
+#include "nsIGlobalObject.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsIXPCScriptable.h"
+
+#include "js/HeapAPI.h"
+
+class XPCWrappedNative;
+
+class BackstagePass : public nsIGlobalObject,
+                      public nsIScriptObjectPrincipal,
+                      public nsIXPCScriptable,
+                      public nsIClassInfo,
+                      public nsSupportsWeakReference
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIXPCSCRIPTABLE
+  NS_DECL_NSICLASSINFO
+
+  virtual nsIPrincipal* GetPrincipal() override {
+    return mPrincipal;
+  }
+
+  virtual JSObject* GetGlobalJSObject() override;
+
+  void ForgetGlobalObject() {
+    mWrapper = nullptr;
+  }
+
+  void SetGlobalObject(JSObject* global);
+
+  explicit BackstagePass(nsIPrincipal* prin) :
+    mPrincipal(prin)
+  {
+  }
+
+private:
+  virtual ~BackstagePass() { }
+
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+  XPCWrappedNative* mWrapper;
+};
+
+nsresult
+NS_NewBackstagePass(BackstagePass** ret);
+
+#endif // BackstagePass_h__
diff --git a/js/xpconnect/src/ExportHelpers.cpp b/js/xpconnect/src/ExportHelpers.cpp
new file mode 100644
index 000000000..3dbf83e3b
--- /dev/null
+++ b/js/xpconnect/src/ExportHelpers.cpp
@@ -0,0 +1,491 @@
+/* -*- 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 "xpcprivate.h"
+#include "WrapperFactory.h"
+#include "AccessCheck.h"
+#include "jsfriendapi.h"
+#include "jswrapper.h"
+#include "js/Proxy.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/BlobBinding.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FileListBinding.h"
+#include "mozilla/dom/StructuredCloneHolder.h"
+#include "nsGlobalWindow.h"
+#include "nsJSUtils.h"
+#include "nsIDOMFileList.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace JS;
+
+namespace xpc {
+
+bool
+IsReflector(JSObject* obj)
+{
+    obj = js::CheckedUnwrap(obj, /* stopAtWindowProxy = */ false);
+    if (!obj)
+        return false;
+    return IS_WN_REFLECTOR(obj) || dom::IsDOMObject(obj);
+}
+
+enum StackScopedCloneTags {
+    SCTAG_BASE = JS_SCTAG_USER_MIN,
+    SCTAG_REFLECTOR,
+    SCTAG_BLOB,
+    SCTAG_FUNCTION,
+};
+
+// The HTML5 structured cloning algorithm includes a few DOM objects, notably
+// FileList. That wouldn't in itself be a reason to support them here,
+// but we've historically supported them for Cu.cloneInto (where we didn't support
+// other reflectors), so we need to continue to do so in the wrapReflectors == false
+// case to maintain compatibility.
+//
+// FileList clones are supposed to give brand new objects, rather than
+// cross-compartment wrappers. For this, our current implementation relies on the
+// fact that these objects are implemented with XPConnect and have one reflector
+// per scope.
+bool IsFileList(JSObject* obj)
+{
+    return IS_INSTANCE_OF(FileList, obj);
+}
+
+class MOZ_STACK_CLASS StackScopedCloneData
+    : public StructuredCloneHolderBase
+{
+public:
+    StackScopedCloneData(JSContext* aCx, StackScopedCloneOptions* aOptions)
+        : mOptions(aOptions)
+        , mReflectors(aCx)
+        , mFunctions(aCx)
+    {}
+
+    ~StackScopedCloneData()
+    {
+        Clear();
+    }
+
+    JSObject* CustomReadHandler(JSContext* aCx,
+                                JSStructuredCloneReader* aReader,
+                                uint32_t aTag,
+                                uint32_t aData)
+    {
+        if (aTag == SCTAG_REFLECTOR) {
+            MOZ_ASSERT(!aData);
+
+            size_t idx;
+            if (!JS_ReadBytes(aReader, &idx, sizeof(size_t)))
+                return nullptr;
+
+            RootedObject reflector(aCx, mReflectors[idx]);
+            MOZ_ASSERT(reflector, "No object pointer?");
+            MOZ_ASSERT(IsReflector(reflector), "Object pointer must be a reflector!");
+
+            if (!JS_WrapObject(aCx, &reflector))
+                return nullptr;
+
+            return reflector;
+        }
+
+        if (aTag == SCTAG_FUNCTION) {
+          MOZ_ASSERT(aData < mFunctions.length());
+
+          RootedValue functionValue(aCx);
+          RootedObject obj(aCx, mFunctions[aData]);
+
+          if (!JS_WrapObject(aCx, &obj))
+              return nullptr;
+
+          FunctionForwarderOptions forwarderOptions;
+          if (!xpc::NewFunctionForwarder(aCx, JSID_VOIDHANDLE, obj, forwarderOptions,
+                                         &functionValue))
+          {
+              return nullptr;
+          }
+
+          return &functionValue.toObject();
+        }
+
+        if (aTag == SCTAG_BLOB) {
+            MOZ_ASSERT(!aData);
+
+            size_t idx;
+            if (!JS_ReadBytes(aReader, &idx, sizeof(size_t))) {
+                return nullptr;
+            }
+
+            nsIGlobalObject* global = xpc::NativeGlobal(JS::CurrentGlobalOrNull(aCx));
+            MOZ_ASSERT(global);
+
+            // RefPtr<File> needs to go out of scope before toObjectOrNull() is called because
+            // otherwise the static analysis thinks it can gc the JSObject via the stack.
+            JS::Rooted<JS::Value> val(aCx);
+            {
+                RefPtr<Blob> blob = Blob::Create(global, mBlobImpls[idx]);
+                if (!ToJSValue(aCx, blob, &val)) {
+                    return nullptr;
+                }
+            }
+
+            return val.toObjectOrNull();
+        }
+
+        MOZ_ASSERT_UNREACHABLE("Encountered garbage in the clone stream!");
+        return nullptr;
+    }
+
+    bool CustomWriteHandler(JSContext* aCx,
+                            JSStructuredCloneWriter* aWriter,
+                            JS::Handle<JSObject*> aObj)
+    {
+        {
+            JS::Rooted<JSObject*> obj(aCx, aObj);
+            Blob* blob = nullptr;
+            if (NS_SUCCEEDED(UNWRAP_OBJECT(Blob, &obj, blob))) {
+                BlobImpl* blobImpl = blob->Impl();
+                MOZ_ASSERT(blobImpl);
+
+                if (!mBlobImpls.AppendElement(blobImpl))
+                    return false;
+
+                size_t idx = mBlobImpls.Length() - 1;
+                return JS_WriteUint32Pair(aWriter, SCTAG_BLOB, 0) &&
+                       JS_WriteBytes(aWriter, &idx, sizeof(size_t));
+            }
+        }
+
+        if ((mOptions->wrapReflectors && IsReflector(aObj)) ||
+            IsFileList(aObj))
+        {
+            if (!mReflectors.append(aObj))
+                return false;
+
+            size_t idx = mReflectors.length() - 1;
+            if (!JS_WriteUint32Pair(aWriter, SCTAG_REFLECTOR, 0))
+                return false;
+            if (!JS_WriteBytes(aWriter, &idx, sizeof(size_t)))
+                return false;
+            return true;
+        }
+
+        if (JS::IsCallable(aObj)) {
+            if (mOptions->cloneFunctions) {
+                if (!mFunctions.append(aObj))
+                    return false;
+                return JS_WriteUint32Pair(aWriter, SCTAG_FUNCTION, mFunctions.length() - 1);
+            } else {
+                JS_ReportErrorASCII(aCx, "Permission denied to pass a Function via structured clone");
+                return false;
+            }
+        }
+
+        JS_ReportErrorASCII(aCx, "Encountered unsupported value type writing stack-scoped structured clone");
+        return false;
+    }
+
+    StackScopedCloneOptions* mOptions;
+    AutoObjectVector mReflectors;
+    AutoObjectVector mFunctions;
+    nsTArray<RefPtr<BlobImpl>> mBlobImpls;
+};
+
+/*
+ * General-purpose structured-cloning utility for cases where the structured
+ * clone buffer is only used in stack-scope (that is to say, the buffer does
+ * not escape from this function). The stack-scoping allows us to pass
+ * references to various JSObjects directly in certain situations without
+ * worrying about lifetime issues.
+ *
+ * This function assumes that |cx| is already entered the compartment we want
+ * to clone to, and that |val| may not be same-compartment with cx. When the
+ * function returns, |val| is set to the result of the clone.
+ */
+bool
+StackScopedClone(JSContext* cx, StackScopedCloneOptions& options,
+                 MutableHandleValue val)
+{
+    StackScopedCloneData data(cx, &options);
+    {
+        // For parsing val we have to enter its compartment.
+        // (unless it's a primitive)
+        Maybe<JSAutoCompartment> ac;
+        if (val.isObject()) {
+            ac.emplace(cx, &val.toObject());
+        } else if (val.isString() && !JS_WrapValue(cx, val)) {
+            return false;
+        }
+
+        if (!data.Write(cx, val))
+            return false;
+    }
+
+    // Now recreate the clones in the target compartment.
+    if (!data.Read(cx, val))
+        return false;
+
+    // Deep-freeze if requested.
+    if (options.deepFreeze && val.isObject()) {
+        RootedObject obj(cx, &val.toObject());
+        if (!JS_DeepFreezeObject(cx, obj))
+            return false;
+    }
+
+    return true;
+}
+
+// Note - This function mirrors the logic of CheckPassToChrome in
+// ChromeObjectWrapper.cpp.
+static bool
+CheckSameOriginArg(JSContext* cx, FunctionForwarderOptions& options, HandleValue v)
+{
+    // Consumers can explicitly opt out of this security check. This is used in
+    // the web console to allow the utility functions to accept cross-origin Windows.
+    if (options.allowCrossOriginArguments)
+        return true;
+
+    // Primitives are fine.
+    if (!v.isObject())
+        return true;
+    RootedObject obj(cx, &v.toObject());
+    MOZ_ASSERT(js::GetObjectCompartment(obj) != js::GetContextCompartment(cx),
+               "This should be invoked after entering the compartment but before "
+               "wrapping the values");
+
+    // Non-wrappers are fine.
+    if (!js::IsWrapper(obj))
+        return true;
+
+    // Wrappers leading back to the scope of the exported function are fine.
+    if (js::GetObjectCompartment(js::UncheckedUnwrap(obj)) == js::GetContextCompartment(cx))
+        return true;
+
+    // Same-origin wrappers are fine.
+    if (AccessCheck::wrapperSubsumes(obj))
+        return true;
+
+    // Badness.
+    JS_ReportErrorASCII(cx, "Permission denied to pass object to exported function");
+    return false;
+}
+
+static bool
+FunctionForwarder(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    // Grab the options from the reserved slot.
+    RootedObject optionsObj(cx, &js::GetFunctionNativeReserved(&args.callee(), 1).toObject());
+    FunctionForwarderOptions options(cx, optionsObj);
+    if (!options.Parse())
+        return false;
+
+    // Grab and unwrap the underlying callable.
+    RootedValue v(cx, js::GetFunctionNativeReserved(&args.callee(), 0));
+    RootedObject unwrappedFun(cx, js::UncheckedUnwrap(&v.toObject()));
+
+    RootedObject thisObj(cx, args.isConstructing() ? nullptr : JS_THIS_OBJECT(cx, vp));
+    {
+        // We manually implement the contents of CrossCompartmentWrapper::call
+        // here, because certain function wrappers (notably content->nsEP) are
+        // not callable.
+        JSAutoCompartment ac(cx, unwrappedFun);
+
+        RootedValue thisVal(cx, ObjectOrNullValue(thisObj));
+        if (!CheckSameOriginArg(cx, options, thisVal) || !JS_WrapObject(cx, &thisObj))
+            return false;
+
+        for (size_t n = 0;  n < args.length(); ++n) {
+            if (!CheckSameOriginArg(cx, options, args[n]) || !JS_WrapValue(cx, args[n]))
+                return false;
+        }
+
+        RootedValue fval(cx, ObjectValue(*unwrappedFun));
+        if (args.isConstructing()) {
+            RootedObject obj(cx);
+            if (!JS::Construct(cx, fval, args, &obj))
+                return false;
+            args.rval().setObject(*obj);
+        } else {
+            if (!JS_CallFunctionValue(cx, thisObj, fval, args, args.rval()))
+                return false;
+        }
+    }
+
+    // Rewrap the return value into our compartment.
+    return JS_WrapValue(cx, args.rval());
+}
+
+bool
+NewFunctionForwarder(JSContext* cx, HandleId idArg, HandleObject callable,
+                     FunctionForwarderOptions& options, MutableHandleValue vp)
+{
+    RootedId id(cx, idArg);
+    if (id == JSID_VOIDHANDLE)
+        id = GetJSIDByIndex(cx, XPCJSContext::IDX_EMPTYSTRING);
+
+    // We have no way of knowing whether the underlying function wants to be a
+    // constructor or not, so we just mark all forwarders as constructors, and
+    // let the underlying function throw for construct calls if it wants.
+    JSFunction* fun = js::NewFunctionByIdWithReserved(cx, FunctionForwarder,
+                                                      0, JSFUN_CONSTRUCTOR, id);
+    if (!fun)
+        return false;
+
+    // Stash the callable in slot 0.
+    AssertSameCompartment(cx, callable);
+    RootedObject funobj(cx, JS_GetFunctionObject(fun));
+    js::SetFunctionNativeReserved(funobj, 0, ObjectValue(*callable));
+
+    // Stash the options in slot 1.
+    RootedObject optionsObj(cx, options.ToJSObject(cx));
+    if (!optionsObj)
+        return false;
+    js::SetFunctionNativeReserved(funobj, 1, ObjectValue(*optionsObj));
+
+    vp.setObject(*funobj);
+    return true;
+}
+
+bool
+ExportFunction(JSContext* cx, HandleValue vfunction, HandleValue vscope, HandleValue voptions,
+               MutableHandleValue rval)
+{
+    bool hasOptions = !voptions.isUndefined();
+    if (!vscope.isObject() || !vfunction.isObject() || (hasOptions && !voptions.isObject())) {
+        JS_ReportErrorASCII(cx, "Invalid argument");
+        return false;
+    }
+
+    RootedObject funObj(cx, &vfunction.toObject());
+    RootedObject targetScope(cx, &vscope.toObject());
+    ExportFunctionOptions options(cx, hasOptions ? &voptions.toObject() : nullptr);
+    if (hasOptions && !options.Parse())
+        return false;
+
+    // Restrictions:
+    // * We must subsume the scope we are exporting to.
+    // * We must subsume the function being exported, because the function
+    //   forwarder manually circumvents security wrapper CALL restrictions.
+    targetScope = js::CheckedUnwrap(targetScope);
+    funObj = js::CheckedUnwrap(funObj);
+    if (!targetScope || !funObj) {
+        JS_ReportErrorASCII(cx, "Permission denied to export function into scope");
+        return false;
+    }
+
+    if (js::IsScriptedProxy(targetScope)) {
+        JS_ReportErrorASCII(cx, "Defining property on proxy object is not allowed");
+        return false;
+    }
+
+    {
+        // We need to operate in the target scope from here on, let's enter
+        // its compartment.
+        JSAutoCompartment ac(cx, targetScope);
+
+        // Unwrapping to see if we have a callable.
+        funObj = UncheckedUnwrap(funObj);
+        if (!JS::IsCallable(funObj)) {
+            JS_ReportErrorASCII(cx, "First argument must be a function");
+            return false;
+        }
+
+        RootedId id(cx, options.defineAs);
+        if (JSID_IS_VOID(id)) {
+            // If there wasn't any function name specified,
+            // copy the name from the function being imported.
+            JSFunction* fun = JS_GetObjectFunction(funObj);
+            RootedString funName(cx, JS_GetFunctionId(fun));
+            if (!funName)
+                funName = JS_AtomizeAndPinString(cx, "");
+
+            if (!JS_StringToId(cx, funName, &id))
+                return false;
+        }
+        MOZ_ASSERT(JSID_IS_STRING(id));
+
+        // The function forwarder will live in the target compartment. Since
+        // this function will be referenced from its private slot, to avoid a
+        // GC hazard, we must wrap it to the same compartment.
+        if (!JS_WrapObject(cx, &funObj))
+            return false;
+
+        // And now, let's create the forwarder function in the target compartment
+        // for the function the be exported.
+        FunctionForwarderOptions forwarderOptions;
+        forwarderOptions.allowCrossOriginArguments = options.allowCrossOriginArguments;
+        if (!NewFunctionForwarder(cx, id, funObj, forwarderOptions, rval)) {
+            JS_ReportErrorASCII(cx, "Exporting function failed");
+            return false;
+        }
+
+        // We have the forwarder function in the target compartment. If
+        // defineAs was set, we also need to define it as a property on
+        // the target.
+        if (!JSID_IS_VOID(options.defineAs)) {
+            if (!JS_DefinePropertyById(cx, targetScope, id, rval,
+                                       JSPROP_ENUMERATE,
+                                       JS_STUBGETTER, JS_STUBSETTER)) {
+                return false;
+            }
+        }
+    }
+
+    // Finally we have to re-wrap the exported function back to the caller compartment.
+    if (!JS_WrapValue(cx, rval))
+        return false;
+
+    return true;
+}
+
+bool
+CreateObjectIn(JSContext* cx, HandleValue vobj, CreateObjectInOptions& options,
+               MutableHandleValue rval)
+{
+    if (!vobj.isObject()) {
+        JS_ReportErrorASCII(cx, "Expected an object as the target scope");
+        return false;
+    }
+
+    RootedObject scope(cx, js::CheckedUnwrap(&vobj.toObject()));
+    if (!scope) {
+        JS_ReportErrorASCII(cx, "Permission denied to create object in the target scope");
+        return false;
+    }
+
+    bool define = !JSID_IS_VOID(options.defineAs);
+
+    if (define && js::IsScriptedProxy(scope)) {
+        JS_ReportErrorASCII(cx, "Defining property on proxy object is not allowed");
+        return false;
+    }
+
+    RootedObject obj(cx);
+    {
+        JSAutoCompartment ac(cx, scope);
+        obj = JS_NewPlainObject(cx);
+        if (!obj)
+            return false;
+
+        if (define) {
+            if (!JS_DefinePropertyById(cx, scope, options.defineAs, obj,
+                                       JSPROP_ENUMERATE,
+                                       JS_STUBGETTER, JS_STUBSETTER))
+                return false;
+        }
+    }
+
+    rval.setObject(*obj);
+    if (!WrapperFactory::WaiveXrayAndWrap(cx, rval))
+        return false;
+
+    return true;
+}
+
+} /* namespace xpc */
diff --git a/js/xpconnect/src/README b/js/xpconnect/src/README
new file mode 100644
index 000000000..260eed6bc
--- /dev/null
+++ b/js/xpconnect/src/README
@@ -0,0 +1,3 @@
+
+see http://www.mozilla.org/scriptable
+
diff --git a/js/xpconnect/src/Sandbox.cpp b/js/xpconnect/src/Sandbox.cpp
new file mode 100644
index 000000000..120772ed2
--- /dev/null
+++ b/js/xpconnect/src/Sandbox.cpp
@@ -0,0 +1,1966 @@
+/* -*- 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/. */
+
+/*
+ * The Components.Sandbox object.
+ */
+
+#include "AccessCheck.h"
+#include "jsfriendapi.h"
+#include "js/Proxy.h"
+#include "js/StructuredClone.h"
+#include "nsContentUtils.h"
+#include "nsGlobalWindow.h"
+#include "nsIScriptContext.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsIURI.h"
+#include "nsJSUtils.h"
+#include "nsNetUtil.h"
+#include "nsNullPrincipal.h"
+#include "nsPrincipal.h"
+#include "WrapperFactory.h"
+#include "xpcprivate.h"
+#include "xpc_make_class.h"
+#include "XPCWrapper.h"
+#include "XrayWrapper.h"
+#include "Crypto.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/BlobBinding.h"
+#include "mozilla/dom/cache/CacheStorage.h"
+#include "mozilla/dom/CSSBinding.h"
+#include "mozilla/dom/DirectoryBinding.h"
+#include "mozilla/dom/IndexedDatabaseManager.h"
+#include "mozilla/dom/Fetch.h"
+#include "mozilla/dom/FileBinding.h"
+#include "mozilla/dom/PromiseBinding.h"
+#include "mozilla/dom/RequestBinding.h"
+#include "mozilla/dom/ResponseBinding.h"
+#ifdef MOZ_WEBRTC
+#include "mozilla/dom/RTCIdentityProviderRegistrar.h"
+#endif
+#include "mozilla/dom/FileReaderBinding.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/TextDecoderBinding.h"
+#include "mozilla/dom/TextEncoderBinding.h"
+#include "mozilla/dom/UnionConversions.h"
+#include "mozilla/dom/URLBinding.h"
+#include "mozilla/dom/URLSearchParamsBinding.h"
+#include "mozilla/dom/XMLHttpRequest.h"
+#include "mozilla/DeferredFinalize.h"
+
+using namespace mozilla;
+using namespace JS;
+using namespace xpc;
+
+using mozilla::dom::DestroyProtoAndIfaceCache;
+using mozilla::dom::IndexedDatabaseManager;
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(SandboxPrivate)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(SandboxPrivate)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+  tmp->UnlinkHostObjectURIs();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(SandboxPrivate)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+  tmp->TraverseHostObjectURIs(cb);
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(SandboxPrivate)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(SandboxPrivate)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(SandboxPrivate)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SandboxPrivate)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIScriptObjectPrincipal)
+  NS_INTERFACE_MAP_ENTRY(nsIScriptObjectPrincipal)
+  NS_INTERFACE_MAP_ENTRY(nsIGlobalObject)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+NS_INTERFACE_MAP_END
+
+const char kScriptSecurityManagerContractID[] = NS_SCRIPTSECURITYMANAGER_CONTRACTID;
+
+class nsXPCComponents_utils_Sandbox : public nsIXPCComponents_utils_Sandbox,
+                                      public nsIXPCScriptable
+{
+public:
+    // Aren't macros nice?
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTS_UTILS_SANDBOX
+    NS_DECL_NSIXPCSCRIPTABLE
+
+public:
+    nsXPCComponents_utils_Sandbox();
+
+private:
+    virtual ~nsXPCComponents_utils_Sandbox();
+
+    static nsresult CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
+                                    JSContext* cx, HandleObject obj,
+                                    const CallArgs& args, bool* _retval);
+};
+
+already_AddRefed<nsIXPCComponents_utils_Sandbox>
+xpc::NewSandboxConstructor()
+{
+    nsCOMPtr<nsIXPCComponents_utils_Sandbox> sbConstructor =
+        new nsXPCComponents_utils_Sandbox();
+    return sbConstructor.forget();
+}
+
+static bool
+SandboxDump(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    if (args.length() == 0)
+        return true;
+
+    RootedString str(cx, ToString(cx, args[0]));
+    if (!str)
+        return false;
+
+    JSAutoByteString utf8str;
+    char* cstr = utf8str.encodeUtf8(cx, str);
+    if (!cstr)
+        return false;
+
+#if defined(XP_MACOSX)
+    // Be nice and convert all \r to \n.
+    char* c = cstr;
+    char* cEnd = cstr + strlen(cstr);
+    while (c < cEnd) {
+        if (*c == '\r')
+            *c = '\n';
+        c++;
+    }
+#endif
+#ifdef ANDROID
+    __android_log_write(ANDROID_LOG_INFO, "GeckoDump", cstr);
+#endif
+
+    fputs(cstr, stdout);
+    fflush(stdout);
+    args.rval().setBoolean(true);
+    return true;
+}
+
+static bool
+SandboxDebug(JSContext* cx, unsigned argc, Value* vp)
+{
+#ifdef DEBUG
+    return SandboxDump(cx, argc, vp);
+#else
+    return true;
+#endif
+}
+
+static bool
+SandboxImport(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    if (args.length() < 1 || args[0].isPrimitive()) {
+        XPCThrower::Throw(NS_ERROR_INVALID_ARG, cx);
+        return false;
+    }
+
+    RootedString funname(cx);
+    if (args.length() > 1) {
+        // Use the second parameter as the function name.
+        funname = ToString(cx, args[1]);
+        if (!funname)
+            return false;
+    } else {
+        // NB: funobj must only be used to get the JSFunction out.
+        RootedObject funobj(cx, &args[0].toObject());
+        if (js::IsProxy(funobj)) {
+            funobj = XPCWrapper::UnsafeUnwrapSecurityWrapper(funobj);
+        }
+
+        JSAutoCompartment ac(cx, funobj);
+
+        RootedValue funval(cx, ObjectValue(*funobj));
+        JSFunction* fun = JS_ValueToFunction(cx, funval);
+        if (!fun) {
+            XPCThrower::Throw(NS_ERROR_INVALID_ARG, cx);
+            return false;
+        }
+
+        // Use the actual function name as the name.
+        funname = JS_GetFunctionId(fun);
+        if (!funname) {
+            XPCThrower::Throw(NS_ERROR_INVALID_ARG, cx);
+            return false;
+        }
+    }
+
+    RootedId id(cx);
+    if (!JS_StringToId(cx, funname, &id))
+        return false;
+
+    // We need to resolve the this object, because this function is used
+    // unbound and should still work and act on the original sandbox.
+    RootedObject thisObject(cx, JS_THIS_OBJECT(cx, vp));
+    if (!thisObject) {
+        XPCThrower::Throw(NS_ERROR_UNEXPECTED, cx);
+        return false;
+    }
+    if (!JS_SetPropertyById(cx, thisObject, id, args[0]))
+        return false;
+
+    args.rval().setUndefined();
+    return true;
+}
+
+static bool
+SandboxCreateCrypto(JSContext* cx, JS::HandleObject obj)
+{
+    MOZ_ASSERT(JS_IsGlobalObject(obj));
+
+    nsIGlobalObject* native = xpc::NativeGlobal(obj);
+    MOZ_ASSERT(native);
+
+    dom::Crypto* crypto = new dom::Crypto();
+    crypto->Init(native);
+    JS::RootedObject wrapped(cx, crypto->WrapObject(cx, nullptr));
+    return JS_DefineProperty(cx, obj, "crypto", wrapped, JSPROP_ENUMERATE);
+}
+
+#ifdef MOZ_WEBRTC
+static bool
+SandboxCreateRTCIdentityProvider(JSContext* cx, JS::HandleObject obj)
+{
+    MOZ_ASSERT(JS_IsGlobalObject(obj));
+
+    nsCOMPtr<nsIGlobalObject> nativeGlobal = xpc::NativeGlobal(obj);
+    MOZ_ASSERT(nativeGlobal);
+
+    dom::RTCIdentityProviderRegistrar* registrar =
+            new dom::RTCIdentityProviderRegistrar(nativeGlobal);
+    JS::RootedObject wrapped(cx, registrar->WrapObject(cx, nullptr));
+    return JS_DefineProperty(cx, obj, "rtcIdentityProvider", wrapped, JSPROP_ENUMERATE);
+}
+#endif
+
+static bool
+SetFetchRequestFromValue(JSContext *cx, RequestOrUSVString& request,
+                         const MutableHandleValue& requestOrUrl)
+{
+    RequestOrUSVStringArgument requestHolder(request);
+    bool noMatch = true;
+    if (requestOrUrl.isObject() &&
+        !requestHolder.TrySetToRequest(cx, requestOrUrl, noMatch, false)) {
+        return false;
+    }
+    if (noMatch &&
+        !requestHolder.TrySetToUSVString(cx, requestOrUrl, noMatch)) {
+        return false;
+    }
+    if (noMatch) {
+        return false;
+    }
+    return true;
+}
+
+static bool
+SandboxFetch(JSContext* cx, JS::HandleObject scope, const CallArgs& args)
+{
+    if (args.length() < 1) {
+        JS_ReportErrorASCII(cx, "fetch requires at least 1 argument");
+        return false;
+    }
+
+    RequestOrUSVString request;
+    if (!SetFetchRequestFromValue(cx, request, args[0])) {
+        JS_ReportErrorASCII(cx, "fetch requires a string or Request in argument 1");
+        return false;
+    }
+    RootedDictionary<dom::RequestInit> options(cx);
+    if (!options.Init(cx, args.hasDefined(1) ? args[1] : JS::NullHandleValue,
+                      "Argument 2 of fetch", false)) {
+        return false;
+    }
+    nsCOMPtr<nsIGlobalObject> global = xpc::NativeGlobal(scope);
+    if (!global) {
+        return false;
+    }
+    ErrorResult rv;
+    RefPtr<dom::Promise> response =
+        FetchRequest(global, Constify(request), Constify(options), rv);
+    if (rv.MaybeSetPendingException(cx)) {
+        return false;
+    }
+
+    args.rval().setObject(*response->PromiseObj());
+    return true;
+}
+
+static bool SandboxFetchPromise(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    RootedObject callee(cx, &args.callee());
+    RootedObject scope(cx, JS::CurrentGlobalOrNull(cx));
+    if (SandboxFetch(cx, scope, args)) {
+        return true;
+    }
+    return ConvertExceptionToPromise(cx, scope, args.rval());
+}
+
+
+static bool
+SandboxCreateFetch(JSContext* cx, HandleObject obj)
+{
+    MOZ_ASSERT(JS_IsGlobalObject(obj));
+
+    return JS_DefineFunction(cx, obj, "fetch", SandboxFetchPromise, 2, 0) &&
+        dom::RequestBinding::GetConstructorObject(cx) &&
+        dom::ResponseBinding::GetConstructorObject(cx) &&
+        dom::HeadersBinding::GetConstructorObject(cx);
+}
+
+static bool
+SandboxIsProxy(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() < 1) {
+        JS_ReportErrorASCII(cx, "Function requires at least 1 argument");
+        return false;
+    }
+    if (!args[0].isObject()) {
+        args.rval().setBoolean(false);
+        return true;
+    }
+
+    RootedObject obj(cx, &args[0].toObject());
+    obj = js::CheckedUnwrap(obj);
+    NS_ENSURE_TRUE(obj, false);
+
+    args.rval().setBoolean(js::IsScriptedProxy(obj));
+    return true;
+}
+
+/*
+ * Expected type of the arguments and the return value:
+ * function exportFunction(function funToExport,
+ *                         object targetScope,
+ *                         [optional] object options)
+ */
+static bool
+SandboxExportFunction(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() < 2) {
+        JS_ReportErrorASCII(cx, "Function requires at least 2 arguments");
+        return false;
+    }
+
+    RootedValue options(cx, args.length() > 2 ? args[2] : UndefinedValue());
+    return ExportFunction(cx, args[0], args[1], options, args.rval());
+}
+
+static bool
+SandboxCreateObjectIn(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() < 1) {
+        JS_ReportErrorASCII(cx, "Function requires at least 1 argument");
+        return false;
+    }
+
+    RootedObject optionsObj(cx);
+    bool calledWithOptions = args.length() > 1;
+    if (calledWithOptions) {
+        if (!args[1].isObject()) {
+            JS_ReportErrorASCII(cx, "Expected the 2nd argument (options) to be an object");
+            return false;
+        }
+        optionsObj = &args[1].toObject();
+    }
+
+    CreateObjectInOptions options(cx, optionsObj);
+    if (calledWithOptions && !options.Parse())
+        return false;
+
+    return xpc::CreateObjectIn(cx, args[0], options, args.rval());
+}
+
+static bool
+SandboxCloneInto(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() < 2) {
+        JS_ReportErrorASCII(cx, "Function requires at least 2 arguments");
+        return false;
+    }
+
+    RootedValue options(cx, args.length() > 2 ? args[2] : UndefinedValue());
+    return xpc::CloneInto(cx, args[0], args[1], options, args.rval());
+}
+
+static void
+sandbox_finalize(js::FreeOp* fop, JSObject* obj)
+{
+    nsIScriptObjectPrincipal* sop =
+        static_cast<nsIScriptObjectPrincipal*>(xpc_GetJSPrivate(obj));
+    if (!sop) {
+        // sop can be null if CreateSandboxObject fails in the middle.
+        return;
+    }
+
+    static_cast<SandboxPrivate*>(sop)->ForgetGlobalObject();
+    DestroyProtoAndIfaceCache(obj);
+    DeferredFinalize(sop);
+}
+
+static void
+sandbox_moved(JSObject* obj, const JSObject* old)
+{
+    // Note that this hook can be called before the private pointer is set. In
+    // this case the SandboxPrivate will not exist yet, so there is nothing to
+    // do.
+    nsIScriptObjectPrincipal* sop =
+        static_cast<nsIScriptObjectPrincipal*>(xpc_GetJSPrivate(obj));
+    if (sop)
+        static_cast<SandboxPrivate*>(sop)->ObjectMoved(obj, old);
+}
+
+static bool
+writeToProto_setProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                         JS::MutableHandleValue vp, JS::ObjectOpResult& result)
+{
+    RootedObject proto(cx);
+    if (!JS_GetPrototype(cx, obj, &proto))
+        return false;
+
+    RootedValue receiver(cx, ObjectValue(*proto));
+    return JS_ForwardSetPropertyTo(cx, proto, id, vp, receiver, result);
+}
+
+static bool
+writeToProto_getProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+                    JS::MutableHandleValue vp)
+{
+    RootedObject proto(cx);
+    if (!JS_GetPrototype(cx, obj, &proto))
+        return false;
+
+    return JS_GetPropertyById(cx, proto, id, vp);
+}
+
+struct AutoSkipPropertyMirroring
+{
+    explicit AutoSkipPropertyMirroring(CompartmentPrivate* priv) : priv(priv) {
+        MOZ_ASSERT(!priv->skipWriteToGlobalPrototype);
+        priv->skipWriteToGlobalPrototype = true;
+    }
+    ~AutoSkipPropertyMirroring() {
+        MOZ_ASSERT(priv->skipWriteToGlobalPrototype);
+        priv->skipWriteToGlobalPrototype = false;
+    }
+
+  private:
+    CompartmentPrivate* priv;
+};
+
+// This hook handles the case when writeToGlobalPrototype is set on the
+// sandbox. This flag asks that any properties defined on the sandbox global
+// also be defined on the sandbox global's prototype. Whenever one of these
+// properties is changed (on either side), the change should be reflected on
+// both sides. We use this functionality to create sandboxes that are
+// essentially "sub-globals" of another global. This is useful for running
+// add-ons in a separate compartment while still giving them access to the
+// chrome window.
+static bool
+sandbox_addProperty(JSContext* cx, HandleObject obj, HandleId id, HandleValue v)
+{
+    CompartmentPrivate* priv = CompartmentPrivate::Get(obj);
+    MOZ_ASSERT(priv->writeToGlobalPrototype);
+
+    // Whenever JS_EnumerateStandardClasses is called, it defines the
+    // "undefined" property, even if it's already defined. We don't want to do
+    // anything in that case.
+    if (id == XPCJSContext::Get()->GetStringID(XPCJSContext::IDX_UNDEFINED))
+        return true;
+
+    // Avoid recursively triggering sandbox_addProperty in the
+    // JS_DefinePropertyById call below.
+    if (priv->skipWriteToGlobalPrototype)
+        return true;
+
+    AutoSkipPropertyMirroring askip(priv);
+
+    RootedObject proto(cx);
+    if (!JS_GetPrototype(cx, obj, &proto))
+        return false;
+
+    // After bug 1015790 is fixed, we should be able to remove this unwrapping.
+    RootedObject unwrappedProto(cx, js::UncheckedUnwrap(proto, /* stopAtWindowProxy = */ false));
+
+    Rooted<JS::PropertyDescriptor> pd(cx);
+    if (!JS_GetPropertyDescriptorById(cx, proto, id, &pd))
+        return false;
+
+    // This is a little icky. If the property exists and is not configurable,
+    // then JS_CopyPropertyFrom will throw an exception when we try to do a
+    // normal assignment since it will think we're trying to remove the
+    // non-configurability. So we do JS_SetPropertyById in that case.
+    //
+    // However, in the case of |const x = 3|, we get called once for
+    // JSOP_DEFCONST and once for JSOP_SETCONST. The first one creates the
+    // property as readonly and configurable. The second one changes the
+    // attributes to readonly and not configurable. If we use JS_SetPropertyById
+    // for the second call, it will throw an exception because the property is
+    // readonly. We have to use JS_CopyPropertyFrom since it ignores the
+    // readonly attribute (as it calls JSObject::defineProperty). See bug
+    // 1019181.
+    if (pd.object() && !pd.configurable()) {
+        if (!JS_SetPropertyById(cx, proto, id, v))
+            return false;
+    } else {
+        if (!JS_CopyPropertyFrom(cx, id, unwrappedProto, obj,
+                                 MakeNonConfigurableIntoConfigurable))
+            return false;
+    }
+
+    if (!JS_GetPropertyDescriptorById(cx, obj, id, &pd))
+        return false;
+    unsigned attrs = pd.attributes() & ~(JSPROP_GETTER | JSPROP_SETTER);
+    if (!JS_DefinePropertyById(cx, obj, id, v,
+                               attrs | JSPROP_PROPOP_ACCESSORS | JSPROP_REDEFINE_NONCONFIGURABLE,
+                               JS_PROPERTYOP_GETTER(writeToProto_getProperty),
+                               JS_PROPERTYOP_SETTER(writeToProto_setProperty)))
+        return false;
+
+    return true;
+}
+
+#define XPCONNECT_SANDBOX_CLASS_METADATA_SLOT (XPCONNECT_GLOBAL_EXTRA_SLOT_OFFSET)
+
+static const js::ClassOps SandboxClassOps = {
+    nullptr, nullptr, nullptr, nullptr,
+    JS_EnumerateStandardClasses, JS_ResolveStandardClass,
+    JS_MayResolveStandardClass,
+    sandbox_finalize,
+    nullptr, nullptr, nullptr, JS_GlobalObjectTraceHook,
+};
+
+static const js::ClassExtension SandboxClassExtension = {
+    nullptr,      /* weakmapKeyDelegateOp */
+    sandbox_moved /* objectMovedOp */
+};
+
+static const js::Class SandboxClass = {
+    "Sandbox",
+    XPCONNECT_GLOBAL_FLAGS_WITH_EXTRA_SLOTS(1) |
+    JSCLASS_FOREGROUND_FINALIZE,
+    &SandboxClassOps,
+    JS_NULL_CLASS_SPEC,
+    &SandboxClassExtension,
+    JS_NULL_OBJECT_OPS
+};
+
+// Note to whomever comes here to remove addProperty hooks: billm has promised
+// to do the work for this class.
+static const js::ClassOps SandboxWriteToProtoClassOps = {
+    sandbox_addProperty, nullptr, nullptr, nullptr,
+    JS_EnumerateStandardClasses, JS_ResolveStandardClass,
+    JS_MayResolveStandardClass,
+    sandbox_finalize,
+    nullptr, nullptr, nullptr, JS_GlobalObjectTraceHook,
+};
+
+static const js::Class SandboxWriteToProtoClass = {
+    "Sandbox",
+    XPCONNECT_GLOBAL_FLAGS_WITH_EXTRA_SLOTS(1) |
+    JSCLASS_FOREGROUND_FINALIZE,
+    &SandboxWriteToProtoClassOps,
+    JS_NULL_CLASS_SPEC,
+    &SandboxClassExtension,
+    JS_NULL_OBJECT_OPS
+};
+
+static const JSFunctionSpec SandboxFunctions[] = {
+    JS_FS("dump",    SandboxDump,    1,0),
+    JS_FS("debug",   SandboxDebug,   1,0),
+    JS_FS("importFunction", SandboxImport, 1,0),
+    JS_FS_END
+};
+
+bool
+xpc::IsSandbox(JSObject* obj)
+{
+    const js::Class* clasp = js::GetObjectClass(obj);
+    return clasp == &SandboxClass || clasp == &SandboxWriteToProtoClass;
+}
+
+/***************************************************************************/
+nsXPCComponents_utils_Sandbox::nsXPCComponents_utils_Sandbox()
+{
+}
+
+nsXPCComponents_utils_Sandbox::~nsXPCComponents_utils_Sandbox()
+{
+}
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_utils_Sandbox)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_utils_Sandbox)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_utils_Sandbox)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_utils_Sandbox)
+NS_IMPL_RELEASE(nsXPCComponents_utils_Sandbox)
+
+// We use the nsIXPScriptable macros to generate lots of stuff for us.
+#define XPC_MAP_CLASSNAME           nsXPCComponents_utils_Sandbox
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_utils_Sandbox"
+#define                             XPC_MAP_WANT_CALL
+#define                             XPC_MAP_WANT_CONSTRUCT
+#define XPC_MAP_FLAGS               0
+#include "xpc_map_end.h" /* This #undef's the above. */
+
+const xpc::SandboxProxyHandler xpc::sandboxProxyHandler;
+
+bool
+xpc::IsSandboxPrototypeProxy(JSObject* obj)
+{
+    return js::IsProxy(obj) &&
+           js::GetProxyHandler(obj) == &xpc::sandboxProxyHandler;
+}
+
+bool
+xpc::SandboxCallableProxyHandler::call(JSContext* cx, JS::Handle<JSObject*> proxy,
+                                       const JS::CallArgs& args) const
+{
+    // We forward the call to our underlying callable.
+
+    // Get our SandboxProxyHandler proxy.
+    RootedObject sandboxProxy(cx, getSandboxProxy(proxy));
+    MOZ_ASSERT(js::IsProxy(sandboxProxy) &&
+               js::GetProxyHandler(sandboxProxy) == &xpc::sandboxProxyHandler);
+
+    // The global of the sandboxProxy is the sandbox global, and the
+    // target object is the original proto.
+    RootedObject sandboxGlobal(cx,
+      js::GetGlobalForObjectCrossCompartment(sandboxProxy));
+    MOZ_ASSERT(IsSandbox(sandboxGlobal));
+
+    // If our this object is the sandbox global, we call with this set to the
+    // original proto instead.
+    //
+    // There are two different ways we can compute |this|. If we use
+    // JS_THIS_VALUE, we'll get the bonafide |this| value as passed by the
+    // caller, which may be undefined if a global function was invoked without
+    // an explicit invocant. If we use JS_THIS or JS_THIS_OBJECT, the |this|
+    // in |vp| will be coerced to the global, which is not the correct
+    // behavior in ES5 strict mode. And we have no way to compute strictness
+    // here.
+    //
+    // The naive approach is simply to use JS_THIS_VALUE here. If |this| was
+    // explicit, we can remap it appropriately. If it was implicit, then we
+    // leave it as undefined, and let the callee sort it out. Since the callee
+    // is generally in the same compartment as its global (eg the Window's
+    // compartment, not the Sandbox's), the callee will generally compute the
+    // correct |this|.
+    //
+    // However, this breaks down in the Xray case. If the sandboxPrototype
+    // is an Xray wrapper, then we'll end up reifying the native methods in
+    // the Sandbox's scope, which means that they'll compute |this| to be the
+    // Sandbox, breaking old-style XPC_WN_CallMethod methods.
+    //
+    // Luckily, the intent of Xrays is to provide a vanilla view of a foreign
+    // DOM interface, which means that we don't care about script-enacted
+    // strictness in the prototype's home compartment. Indeed, since DOM
+    // methods are always non-strict, we can just assume non-strict semantics
+    // if the sandboxPrototype is an Xray Wrapper, which lets us appropriately
+    // remap |this|.
+    bool isXray = WrapperFactory::IsXrayWrapper(sandboxProxy);
+    RootedValue thisVal(cx, isXray ? args.computeThis(cx) : args.thisv());
+    if (thisVal == ObjectValue(*sandboxGlobal)) {
+        thisVal = ObjectValue(*js::GetProxyTargetObject(sandboxProxy));
+    }
+
+    RootedValue func(cx, js::GetProxyPrivate(proxy));
+    return JS::Call(cx, thisVal, func, args, args.rval());
+}
+
+const xpc::SandboxCallableProxyHandler xpc::sandboxCallableProxyHandler;
+
+/*
+ * Wrap a callable such that if we're called with oldThisObj as the
+ * "this" we will instead call it with newThisObj as the this.
+ */
+static JSObject*
+WrapCallable(JSContext* cx, HandleObject callable, HandleObject sandboxProtoProxy)
+{
+    MOZ_ASSERT(JS::IsCallable(callable));
+    // Our proxy is wrapping the callable.  So we need to use the
+    // callable as the private.  We put the given sandboxProtoProxy in
+    // an extra slot, and our call() hook depends on that.
+    MOZ_ASSERT(js::IsProxy(sandboxProtoProxy) &&
+               js::GetProxyHandler(sandboxProtoProxy) ==
+                 &xpc::sandboxProxyHandler);
+
+    RootedValue priv(cx, ObjectValue(*callable));
+    // We want to claim to have the same proto as our wrapped callable, so set
+    // ourselves up with a lazy proto.
+    js::ProxyOptions options;
+    options.setLazyProto(true);
+    JSObject* obj = js::NewProxyObject(cx, &xpc::sandboxCallableProxyHandler,
+                                       priv, nullptr, options);
+    if (obj) {
+        js::SetProxyExtra(obj, SandboxCallableProxyHandler::SandboxProxySlot,
+                          ObjectValue(*sandboxProtoProxy));
+    }
+
+    return obj;
+}
+
+template<typename Op>
+bool WrapAccessorFunction(JSContext* cx, Op& op, PropertyDescriptor* desc,
+                          unsigned attrFlag, HandleObject sandboxProtoProxy)
+{
+    if (!op) {
+        return true;
+    }
+
+    if (!(desc->attrs & attrFlag)) {
+        XPCThrower::Throw(NS_ERROR_UNEXPECTED, cx);
+        return false;
+    }
+
+    RootedObject func(cx, JS_FUNC_TO_DATA_PTR(JSObject*, op));
+    func = WrapCallable(cx, func, sandboxProtoProxy);
+    if (!func)
+        return false;
+    op = JS_DATA_TO_FUNC_PTR(Op, func.get());
+    return true;
+}
+
+bool
+xpc::SandboxProxyHandler::getPropertyDescriptor(JSContext* cx,
+                                                JS::Handle<JSObject*> proxy,
+                                                JS::Handle<jsid> id,
+                                                JS::MutableHandle<PropertyDescriptor> desc) const
+{
+    JS::RootedObject obj(cx, wrappedObject(proxy));
+
+    MOZ_ASSERT(js::GetObjectCompartment(obj) == js::GetObjectCompartment(proxy));
+    if (!JS_GetPropertyDescriptorById(cx, obj, id, desc))
+        return false;
+
+    if (!desc.object())
+        return true; // No property, nothing to do
+
+    // Now fix up the getter/setter/value as needed to be bound to desc->obj.
+    if (!WrapAccessorFunction(cx, desc.getter(), desc.address(),
+                              JSPROP_GETTER, proxy))
+        return false;
+    if (!WrapAccessorFunction(cx, desc.setter(), desc.address(),
+                              JSPROP_SETTER, proxy))
+        return false;
+    if (desc.value().isObject()) {
+        RootedObject val (cx, &desc.value().toObject());
+        if (JS::IsCallable(val)) {
+            val = WrapCallable(cx, val, proxy);
+            if (!val)
+                return false;
+            desc.value().setObject(*val);
+        }
+    }
+
+    return true;
+}
+
+bool
+xpc::SandboxProxyHandler::getOwnPropertyDescriptor(JSContext* cx,
+                                                   JS::Handle<JSObject*> proxy,
+                                                   JS::Handle<jsid> id,
+                                                   JS::MutableHandle<PropertyDescriptor> desc)
+                                                   const
+{
+    if (!getPropertyDescriptor(cx, proxy, id, desc))
+        return false;
+
+    if (desc.object() != wrappedObject(proxy))
+        desc.object().set(nullptr);
+
+    return true;
+}
+
+/*
+ * Reuse the BaseProxyHandler versions of the derived traps that are implemented
+ * in terms of the fundamental traps.
+ */
+
+bool
+xpc::SandboxProxyHandler::has(JSContext* cx, JS::Handle<JSObject*> proxy,
+                              JS::Handle<jsid> id, bool* bp) const
+{
+    // This uses getPropertyDescriptor for backward compatibility with
+    // the old BaseProxyHandler::has implementation.
+    Rooted<PropertyDescriptor> desc(cx);
+    if (!getPropertyDescriptor(cx, proxy, id, &desc))
+        return false;
+
+    *bp = !!desc.object();
+    return true;
+}
+bool
+xpc::SandboxProxyHandler::hasOwn(JSContext* cx, JS::Handle<JSObject*> proxy,
+                                 JS::Handle<jsid> id, bool* bp) const
+{
+    return BaseProxyHandler::hasOwn(cx, proxy, id, bp);
+}
+
+bool
+xpc::SandboxProxyHandler::get(JSContext* cx, JS::Handle<JSObject*> proxy,
+                              JS::Handle<JS::Value> receiver,
+                              JS::Handle<jsid> id,
+                              JS::MutableHandle<Value> vp) const
+{
+    // This uses getPropertyDescriptor for backward compatibility with
+    // the old BaseProxyHandler::get implementation.
+    Rooted<PropertyDescriptor> desc(cx);
+    if (!getPropertyDescriptor(cx, proxy, id, &desc))
+        return false;
+    desc.assertCompleteIfFound();
+
+    if (!desc.object()) {
+        vp.setUndefined();
+        return true;
+    }
+
+    // Everything after here follows [[Get]] for ordinary objects.
+    if (desc.isDataDescriptor()) {
+        vp.set(desc.value());
+        return true;
+    }
+
+    MOZ_ASSERT(desc.isAccessorDescriptor());
+    RootedObject getter(cx, desc.getterObject());
+
+    if (!getter) {
+        vp.setUndefined();
+        return true;
+    }
+
+    return Call(cx, receiver, getter, HandleValueArray::empty(), vp);
+}
+
+bool
+xpc::SandboxProxyHandler::set(JSContext* cx, JS::Handle<JSObject*> proxy,
+                              JS::Handle<jsid> id,
+                              JS::Handle<Value> v,
+                              JS::Handle<Value> receiver,
+                              JS::ObjectOpResult& result) const
+{
+    return BaseProxyHandler::set(cx, proxy, id, v, receiver, result);
+}
+
+bool
+xpc::SandboxProxyHandler::getOwnEnumerablePropertyKeys(JSContext* cx,
+                                                       JS::Handle<JSObject*> proxy,
+                                                       AutoIdVector& props) const
+{
+    return BaseProxyHandler::getOwnEnumerablePropertyKeys(cx, proxy, props);
+}
+
+bool
+xpc::SandboxProxyHandler::enumerate(JSContext* cx, JS::Handle<JSObject*> proxy,
+                                    JS::MutableHandle<JSObject*> objp) const
+{
+    return BaseProxyHandler::enumerate(cx, proxy, objp);
+}
+
+bool
+xpc::GlobalProperties::Parse(JSContext* cx, JS::HandleObject obj)
+{
+    uint32_t length;
+    bool ok = JS_GetArrayLength(cx, obj, &length);
+    NS_ENSURE_TRUE(ok, false);
+    for (uint32_t i = 0; i < length; i++) {
+        RootedValue nameValue(cx);
+        ok = JS_GetElement(cx, obj, i, &nameValue);
+        NS_ENSURE_TRUE(ok, false);
+        if (!nameValue.isString()) {
+            JS_ReportErrorASCII(cx, "Property names must be strings");
+            return false;
+        }
+        RootedString nameStr(cx, nameValue.toString());
+        JSAutoByteString name;
+        if (!name.encodeUtf8(cx, nameStr))
+            return false;
+        if (!strcmp(name.ptr(), "CSS")) {
+            CSS = true;
+        } else if (!strcmp(name.ptr(), "indexedDB")) {
+            indexedDB = true;
+        } else if (!strcmp(name.ptr(), "XMLHttpRequest")) {
+            XMLHttpRequest = true;
+        } else if (!strcmp(name.ptr(), "TextEncoder")) {
+            TextEncoder = true;
+        } else if (!strcmp(name.ptr(), "TextDecoder")) {
+            TextDecoder = true;
+        } else if (!strcmp(name.ptr(), "URL")) {
+            URL = true;
+        } else if (!strcmp(name.ptr(), "URLSearchParams")) {
+            URLSearchParams = true;
+        } else if (!strcmp(name.ptr(), "atob")) {
+            atob = true;
+        } else if (!strcmp(name.ptr(), "btoa")) {
+            btoa = true;
+        } else if (!strcmp(name.ptr(), "Blob")) {
+            Blob = true;
+        } else if (!strcmp(name.ptr(), "Directory")) {
+            Directory = true;
+        } else if (!strcmp(name.ptr(), "File")) {
+            File = true;
+        } else if (!strcmp(name.ptr(), "crypto")) {
+            crypto = true;
+#ifdef MOZ_WEBRTC
+        } else if (!strcmp(name.ptr(), "rtcIdentityProvider")) {
+            rtcIdentityProvider = true;
+#endif
+        } else if (!strcmp(name.ptr(), "fetch")) {
+            fetch = true;
+        } else if (!strcmp(name.ptr(), "caches")) {
+            caches = true;
+        } else if (!strcmp(name.ptr(), "FileReader")) {
+            fileReader = true;
+        } else {
+            JS_ReportErrorUTF8(cx, "Unknown property name: %s", name.ptr());
+            return false;
+        }
+    }
+    return true;
+}
+
+bool
+xpc::GlobalProperties::Define(JSContext* cx, JS::HandleObject obj)
+{
+    MOZ_ASSERT(js::GetContextCompartment(cx) == js::GetObjectCompartment(obj));
+    // Properties will be exposed to System automatically but not to Sandboxes
+    // if |[Exposed=System]| is specified.
+    // This function holds common properties not exposed automatically but able
+    // to be requested either in |Cu.importGlobalProperties| or
+    // |wantGlobalProperties| of a sandbox.
+    if (CSS && !dom::CSSBinding::GetConstructorObject(cx))
+        return false;
+
+    if (XMLHttpRequest &&
+        !dom::XMLHttpRequestBinding::GetConstructorObject(cx))
+        return false;
+
+    if (TextEncoder &&
+        !dom::TextEncoderBinding::GetConstructorObject(cx))
+        return false;
+
+    if (TextDecoder &&
+        !dom::TextDecoderBinding::GetConstructorObject(cx))
+        return false;
+
+    if (URL &&
+        !dom::URLBinding::GetConstructorObject(cx))
+        return false;
+
+    if (URLSearchParams &&
+        !dom::URLSearchParamsBinding::GetConstructorObject(cx))
+        return false;
+
+    if (atob &&
+        !JS_DefineFunction(cx, obj, "atob", Atob, 1, 0))
+        return false;
+
+    if (btoa &&
+        !JS_DefineFunction(cx, obj, "btoa", Btoa, 1, 0))
+        return false;
+
+    if (Blob &&
+        !dom::BlobBinding::GetConstructorObject(cx))
+        return false;
+
+    if (Directory &&
+        !dom::DirectoryBinding::GetConstructorObject(cx))
+        return false;
+
+    if (File &&
+        !dom::FileBinding::GetConstructorObject(cx))
+        return false;
+
+    if (crypto && !SandboxCreateCrypto(cx, obj))
+        return false;
+
+#ifdef MOZ_WEBRTC
+    if (rtcIdentityProvider && !SandboxCreateRTCIdentityProvider(cx, obj))
+        return false;
+#endif
+
+    if (fetch && !SandboxCreateFetch(cx, obj))
+        return false;
+
+    if (caches && !dom::cache::CacheStorage::DefineCaches(cx, obj))
+        return false;
+
+    if (fileReader && !dom::FileReaderBinding::GetConstructorObject(cx))
+        return false;
+
+    return true;
+}
+
+bool
+xpc::GlobalProperties::DefineInXPCComponents(JSContext* cx, JS::HandleObject obj)
+{
+    if (indexedDB &&
+        !IndexedDatabaseManager::DefineIndexedDB(cx, obj))
+        return false;
+
+    return Define(cx, obj);
+}
+
+bool
+xpc::GlobalProperties::DefineInSandbox(JSContext* cx, JS::HandleObject obj)
+{
+    MOZ_ASSERT(IsSandbox(obj));
+    MOZ_ASSERT(js::GetContextCompartment(cx) == js::GetObjectCompartment(obj));
+
+    if (indexedDB &&
+        !(IndexedDatabaseManager::ResolveSandboxBinding(cx) &&
+          IndexedDatabaseManager::DefineIndexedDB(cx, obj)))
+        return false;
+
+    return Define(cx, obj);
+}
+
+nsresult
+xpc::CreateSandboxObject(JSContext* cx, MutableHandleValue vp, nsISupports* prinOrSop,
+                         SandboxOptions& options)
+{
+    // Create the sandbox global object
+    nsCOMPtr<nsIPrincipal> principal = do_QueryInterface(prinOrSop);
+    if (!principal) {
+        nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(prinOrSop);
+        if (sop) {
+            principal = sop->GetPrincipal();
+        } else {
+            RefPtr<nsNullPrincipal> nullPrin = nsNullPrincipal::Create();
+            principal = nullPrin;
+        }
+    }
+    MOZ_ASSERT(principal);
+
+    JS::CompartmentOptions compartmentOptions;
+
+    auto& creationOptions = compartmentOptions.creationOptions();
+
+    // XXXjwatt: Consider whether/when sandboxes should be able to see
+    // [SecureContext] API (bug 1273687).  In that case we'd call
+    // creationOptions.setSecureContext(true).
+
+    if (xpc::SharedMemoryEnabled())
+        creationOptions.setSharedMemoryAndAtomicsEnabled(true);
+
+    if (options.sameZoneAs)
+        creationOptions.setSameZoneAs(js::UncheckedUnwrap(options.sameZoneAs));
+    else if (options.freshZone)
+        creationOptions.setZone(JS::FreshZone);
+    else
+        creationOptions.setZone(JS::SystemZone);
+
+    creationOptions.setInvisibleToDebugger(options.invisibleToDebugger)
+                   .setTrace(TraceXPCGlobal);
+
+    // Try to figure out any addon this sandbox should be associated with.
+    // The addon could have been passed in directly, as part of the metadata,
+    // or by being constructed from an addon's code.
+    JSAddonId* addonId = nullptr;
+    if (options.addonId) {
+        addonId = JS::NewAddonId(cx, options.addonId);
+        NS_ENSURE_TRUE(addonId, NS_ERROR_FAILURE);
+    } else if (JSObject* obj = JS::CurrentGlobalOrNull(cx)) {
+        if (JSAddonId* id = JS::AddonIdOfObject(obj))
+            addonId = id;
+    }
+
+    creationOptions.setAddonId(addonId);
+
+    compartmentOptions.behaviors().setDiscardSource(options.discardSource);
+
+    const js::Class* clasp = options.writeToGlobalPrototype
+                             ? &SandboxWriteToProtoClass
+                             : &SandboxClass;
+
+    RootedObject sandbox(cx, xpc::CreateGlobalObject(cx, js::Jsvalify(clasp),
+                                                     principal, compartmentOptions));
+    if (!sandbox)
+        return NS_ERROR_FAILURE;
+
+    CompartmentPrivate* priv = CompartmentPrivate::Get(sandbox);
+    priv->allowWaivers = options.allowWaivers;
+    priv->writeToGlobalPrototype = options.writeToGlobalPrototype;
+    priv->isWebExtensionContentScript = options.isWebExtensionContentScript;
+    priv->waiveInterposition = options.waiveInterposition;
+
+    // Set up the wantXrays flag, which indicates whether xrays are desired even
+    // for same-origin access.
+    //
+    // This flag has historically been ignored for chrome sandboxes due to
+    // quirks in the wrapping implementation that have now been removed. Indeed,
+    // same-origin Xrays for chrome->chrome access seems a bit superfluous.
+    // Arguably we should just flip the default for chrome and still honor the
+    // flag, but such a change would break code in subtle ways for minimal
+    // benefit. So we just switch it off here.
+    priv->wantXrays =
+      AccessCheck::isChrome(sandbox) ? false : options.wantXrays;
+
+    {
+        JSAutoCompartment ac(cx, sandbox);
+
+        nsCOMPtr<nsIScriptObjectPrincipal> sbp =
+            new SandboxPrivate(principal, sandbox);
+
+        // Pass on ownership of sbp to |sandbox|.
+        JS_SetPrivate(sandbox, sbp.forget().take());
+
+        {
+            // Don't try to mirror standard class properties, if we're using a
+            // mirroring sandbox.  (This is meaningless for non-mirroring
+            // sandboxes.)
+            AutoSkipPropertyMirroring askip(CompartmentPrivate::Get(sandbox));
+
+            // Ensure |Object.prototype| is instantiated before prototype-
+            // splicing below.  For write-to-global-prototype behavior, extend
+            // this to all builtin properties.
+            if (options.writeToGlobalPrototype) {
+                if (!JS_EnumerateStandardClasses(cx, sandbox))
+                    return NS_ERROR_XPC_UNEXPECTED;
+            } else {
+                if (!JS_GetObjectPrototype(cx, sandbox))
+                    return NS_ERROR_XPC_UNEXPECTED;
+            }
+        }
+
+        if (options.proto) {
+            bool ok = JS_WrapObject(cx, &options.proto);
+            if (!ok)
+                return NS_ERROR_XPC_UNEXPECTED;
+
+            // Now check what sort of thing we've got in |proto|, and figure out
+            // if we need a SandboxProxyHandler.
+            //
+            // Note that, in the case of a window, we can't require that the
+            // Sandbox subsumes the prototype, because we have to hold our
+            // reference to it via an outer window, and the window may navigate
+            // at any time. So we have to handle that case separately.
+            bool useSandboxProxy = !!WindowOrNull(js::UncheckedUnwrap(options.proto, false));
+            if (!useSandboxProxy) {
+                JSObject* unwrappedProto = js::CheckedUnwrap(options.proto, false);
+                if (!unwrappedProto) {
+                    JS_ReportErrorASCII(cx, "Sandbox must subsume sandboxPrototype");
+                    return NS_ERROR_INVALID_ARG;
+                }
+                const js::Class* unwrappedClass = js::GetObjectClass(unwrappedProto);
+                useSandboxProxy = IS_WN_CLASS(unwrappedClass) ||
+                                  mozilla::dom::IsDOMClass(Jsvalify(unwrappedClass));
+            }
+
+            if (useSandboxProxy) {
+                // Wrap it up in a proxy that will do the right thing in terms
+                // of this-binding for methods.
+                RootedValue priv(cx, ObjectValue(*options.proto));
+                options.proto = js::NewProxyObject(cx, &xpc::sandboxProxyHandler,
+                                                   priv, nullptr);
+                if (!options.proto)
+                    return NS_ERROR_OUT_OF_MEMORY;
+            }
+
+            ok = JS_SplicePrototype(cx, sandbox, options.proto);
+            if (!ok)
+                return NS_ERROR_XPC_UNEXPECTED;
+        }
+
+        // Don't try to mirror the properties that are set below.
+        AutoSkipPropertyMirroring askip(CompartmentPrivate::Get(sandbox));
+
+        bool allowComponents = principal == nsXPConnect::SystemPrincipal() ||
+                               nsContentUtils::IsExpandedPrincipal(principal);
+        if (options.wantComponents && allowComponents &&
+            !ObjectScope(sandbox)->AttachComponentsObject(cx))
+            return NS_ERROR_XPC_UNEXPECTED;
+
+        if (!XPCNativeWrapper::AttachNewConstructorObject(cx, sandbox))
+            return NS_ERROR_XPC_UNEXPECTED;
+
+        if (!JS_DefineFunctions(cx, sandbox, SandboxFunctions))
+            return NS_ERROR_XPC_UNEXPECTED;
+
+        if (options.wantExportHelpers &&
+            (!JS_DefineFunction(cx, sandbox, "exportFunction", SandboxExportFunction, 3, 0) ||
+             !JS_DefineFunction(cx, sandbox, "createObjectIn", SandboxCreateObjectIn, 2, 0) ||
+             !JS_DefineFunction(cx, sandbox, "cloneInto", SandboxCloneInto, 3, 0) ||
+             !JS_DefineFunction(cx, sandbox, "isProxy", SandboxIsProxy, 1, 0)))
+            return NS_ERROR_XPC_UNEXPECTED;
+
+        if (!options.globalProperties.DefineInSandbox(cx, sandbox))
+            return NS_ERROR_XPC_UNEXPECTED;
+
+#ifndef SPIDERMONKEY_PROMISE
+        // Promise is supposed to be part of ES, and therefore should appear on
+        // every global.
+        if (!dom::PromiseBinding::GetConstructorObject(cx))
+            return NS_ERROR_XPC_UNEXPECTED;
+#endif // SPIDERMONKEY_PROMISE
+    }
+
+    // We handle the case where the context isn't in a compartment for the
+    // benefit of InitSingletonScopes.
+    vp.setObject(*sandbox);
+    if (js::GetContextCompartment(cx) && !JS_WrapValue(cx, vp))
+        return NS_ERROR_UNEXPECTED;
+
+    // Set the location information for the new global, so that tools like
+    // about:memory may use that information
+    xpc::SetLocationForGlobal(sandbox, options.sandboxName);
+
+    xpc::SetSandboxMetadata(cx, sandbox, options.metadata);
+
+    JS_FireOnNewGlobalObject(cx, sandbox);
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_utils_Sandbox::Call(nsIXPConnectWrappedNative* wrapper, JSContext* cx,
+                                    JSObject* objArg, const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_utils_Sandbox::Construct(nsIXPConnectWrappedNative* wrapper, JSContext* cx,
+                                         JSObject* objArg, const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+}
+
+/*
+ * For sandbox constructor the first argument can be a URI string in which case
+ * we use the related Codebase Principal for the sandbox.
+ */
+bool
+ParsePrincipal(JSContext* cx, HandleString codebase, const PrincipalOriginAttributes& aAttrs,
+               nsIPrincipal** principal)
+{
+    MOZ_ASSERT(principal);
+    MOZ_ASSERT(codebase);
+    nsCOMPtr<nsIURI> uri;
+    nsAutoJSString codebaseStr;
+    NS_ENSURE_TRUE(codebaseStr.init(cx, codebase), false);
+    nsresult rv = NS_NewURI(getter_AddRefs(uri), codebaseStr);
+    if (NS_FAILED(rv)) {
+        JS_ReportErrorASCII(cx, "Creating URI from string failed");
+        return false;
+    }
+
+    // We could allow passing in the app-id and browser-element info to the
+    // sandbox constructor. But creating a sandbox based on a string is a
+    // deprecated API so no need to add features to it.
+    nsCOMPtr<nsIPrincipal> prin =
+        BasePrincipal::CreateCodebasePrincipal(uri, aAttrs);
+    prin.forget(principal);
+
+    if (!*principal) {
+        JS_ReportErrorASCII(cx, "Creating Principal from URI failed");
+        return false;
+    }
+    return true;
+}
+
+/*
+ * For sandbox constructor the first argument can be a principal object or
+ * a script object principal (Document, Window).
+ */
+static bool
+GetPrincipalOrSOP(JSContext* cx, HandleObject from, nsISupports** out)
+{
+    MOZ_ASSERT(out);
+    *out = nullptr;
+
+    nsCOMPtr<nsISupports> native = xpc::UnwrapReflectorToISupports(from);
+
+    if (nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(native)) {
+        sop.forget(out);
+        return true;
+    }
+
+    nsCOMPtr<nsIPrincipal> principal = do_QueryInterface(native);
+    principal.forget(out);
+    NS_ENSURE_TRUE(*out, false);
+
+    return true;
+}
+
+/*
+ * The first parameter of the sandbox constructor might be an array of principals, either in string
+ * format or actual objects (see GetPrincipalOrSOP)
+ */
+static bool
+GetExpandedPrincipal(JSContext* cx, HandleObject arrayObj,
+                     const SandboxOptions& options, nsIExpandedPrincipal** out)
+{
+    MOZ_ASSERT(out);
+    uint32_t length;
+
+    if (!JS_GetArrayLength(cx, arrayObj, &length))
+        return false;
+    if (!length) {
+        // We need a whitelist of principals or uri strings to create an
+        // expanded principal, if we got an empty array or something else
+        // report error.
+        JS_ReportErrorASCII(cx, "Expected an array of URI strings");
+        return false;
+    }
+
+    nsTArray< nsCOMPtr<nsIPrincipal> > allowedDomains(length);
+    allowedDomains.SetLength(length);
+
+    // If an originAttributes option has been specified, we will use that as the
+    // OriginAttribute of all of the string arguments passed to this function.
+    // Otherwise, we will use the OriginAttributes of a principal or SOP object
+    // in the array, if any.  If no such object is present, and all we have are
+    // strings, then we will use a default OriginAttribute.
+    // Otherwise, we will use the origin attributes of the passed object(s). If
+    // more than one object is specified, we ensure that the OAs match.
+    Maybe<PrincipalOriginAttributes> attrs;
+    if (options.originAttributes) {
+        attrs.emplace();
+        JS::RootedValue val(cx, JS::ObjectValue(*options.originAttributes));
+        if (!attrs->Init(cx, val)) {
+            // The originAttributes option, if specified, must be valid!
+            JS_ReportErrorASCII(cx, "Expected a valid OriginAttributes object");
+            return false;
+        }
+    }
+
+    // Now we go over the array in two passes.  In the first pass, we ignore
+    // strings, and only process objects.  Assuming that no originAttributes
+    // option has been passed, if we encounter a principal or SOP object, we
+    // grab its OA and save it if it's the first OA encountered, otherwise
+    // check to make sure that it is the same as the OA found before.
+    // In the second pass, we ignore objects, and use the OA found in pass 0
+    // (or the previously computed OA if we have obtained it from the options)
+    // to construct codebase principals.
+    //
+    // The effective OA selected above will also be set as the OA of the
+    // expanded principal object.
+
+    // First pass:
+    for (uint32_t i = 0; i < length; ++i) {
+        RootedValue allowed(cx);
+        if (!JS_GetElement(cx, arrayObj, i, &allowed))
+            return false;
+
+        nsresult rv;
+        nsCOMPtr<nsIPrincipal> principal;
+        if (allowed.isObject()) {
+            // In case of object let's see if it's a Principal or a ScriptObjectPrincipal.
+            nsCOMPtr<nsISupports> prinOrSop;
+            RootedObject obj(cx, &allowed.toObject());
+            if (!GetPrincipalOrSOP(cx, obj, getter_AddRefs(prinOrSop)))
+                return false;
+
+            nsCOMPtr<nsIScriptObjectPrincipal> sop(do_QueryInterface(prinOrSop));
+            principal = do_QueryInterface(prinOrSop);
+            if (sop)
+                principal = sop->GetPrincipal();
+            NS_ENSURE_TRUE(principal, false);
+
+            if (!options.originAttributes) {
+                const PrincipalOriginAttributes prinAttrs =
+                    BasePrincipal::Cast(principal)->OriginAttributesRef();
+                if (attrs.isNothing()) {
+                    attrs.emplace(prinAttrs);
+                } else if (prinAttrs != attrs.ref()) {
+                    // If attrs is from a previously encountered principal in the
+                    // array, we need to ensure that it matches the OA of the
+                    // principal we have here.
+                    // If attrs comes from OriginAttributes, we don't need
+                    // this check.
+                    return false;
+                }
+            }
+
+            // We do not allow ExpandedPrincipals to contain any system principals.
+            bool isSystem;
+            rv = nsXPConnect::SecurityManager()->IsSystemPrincipal(principal, &isSystem);
+            NS_ENSURE_SUCCESS(rv, false);
+            if (isSystem) {
+                JS_ReportErrorASCII(cx, "System principal is not allowed in an expanded principal");
+                return false;
+            }
+            allowedDomains[i] = principal;
+        } else if (allowed.isString()) {
+            // Skip any string arguments - we handle them in the next pass.
+        } else {
+            // Don't know what this is.
+            return false;
+        }
+    }
+
+    if (attrs.isNothing()) {
+        // If no OriginAttributes was found in the first pass, fall back to a default one.
+        attrs.emplace();
+    }
+
+    // Second pass:
+    for (uint32_t i = 0; i < length; ++i) {
+        RootedValue allowed(cx);
+        if (!JS_GetElement(cx, arrayObj, i, &allowed))
+            return false;
+
+        nsCOMPtr<nsIPrincipal> principal;
+        if (allowed.isString()) {
+            // In case of string let's try to fetch a codebase principal from it.
+            RootedString str(cx, allowed.toString());
+
+            // attrs here is either a default OriginAttributes in case the
+            // originAttributes option isn't specified, and no object in the array
+            // provides a principal.  Otherwise it's either the forced principal, or
+            // the principal found before, so we can use it here.
+            if (!ParsePrincipal(cx, str, attrs.ref(), getter_AddRefs(principal)))
+                return false;
+            NS_ENSURE_TRUE(principal, false);
+            allowedDomains[i] = principal;
+        } else {
+            MOZ_ASSERT(allowed.isObject());
+        }
+    }
+
+    nsCOMPtr<nsIExpandedPrincipal> result =
+        new nsExpandedPrincipal(allowedDomains, attrs.ref());
+    result.forget(out);
+    return true;
+}
+
+/*
+ * Helper that tries to get a property from the options object.
+ */
+bool
+OptionsBase::ParseValue(const char* name, MutableHandleValue prop, bool* aFound)
+{
+    bool found;
+    bool ok = JS_HasProperty(mCx, mObject, name, &found);
+    NS_ENSURE_TRUE(ok, false);
+
+    if (aFound)
+        *aFound = found;
+
+    if (!found)
+        return true;
+
+    return JS_GetProperty(mCx, mObject, name, prop);
+}
+
+/*
+ * Helper that tries to get a boolean property from the options object.
+ */
+bool
+OptionsBase::ParseBoolean(const char* name, bool* prop)
+{
+    MOZ_ASSERT(prop);
+    RootedValue value(mCx);
+    bool found;
+    bool ok = ParseValue(name, &value, &found);
+    NS_ENSURE_TRUE(ok, false);
+
+    if (!found)
+        return true;
+
+    if (!value.isBoolean()) {
+        JS_ReportErrorASCII(mCx, "Expected a boolean value for property %s", name);
+        return false;
+    }
+
+    *prop = value.toBoolean();
+    return true;
+}
+
+/*
+ * Helper that tries to get an object property from the options object.
+ */
+bool
+OptionsBase::ParseObject(const char* name, MutableHandleObject prop)
+{
+    RootedValue value(mCx);
+    bool found;
+    bool ok = ParseValue(name, &value, &found);
+    NS_ENSURE_TRUE(ok, false);
+
+    if (!found)
+        return true;
+
+    if (!value.isObject()) {
+        JS_ReportErrorASCII(mCx, "Expected an object value for property %s", name);
+        return false;
+    }
+    prop.set(&value.toObject());
+    return true;
+}
+
+/*
+ * Helper that tries to get an object property from the options object.
+ */
+bool
+OptionsBase::ParseJSString(const char* name, MutableHandleString prop)
+{
+    RootedValue value(mCx);
+    bool found;
+    bool ok = ParseValue(name, &value, &found);
+    NS_ENSURE_TRUE(ok, false);
+
+    if (!found)
+        return true;
+
+    if (!value.isString()) {
+        JS_ReportErrorASCII(mCx, "Expected a string value for property %s", name);
+        return false;
+    }
+    prop.set(value.toString());
+    return true;
+}
+
+/*
+ * Helper that tries to get a string property from the options object.
+ */
+bool
+OptionsBase::ParseString(const char* name, nsCString& prop)
+{
+    RootedValue value(mCx);
+    bool found;
+    bool ok = ParseValue(name, &value, &found);
+    NS_ENSURE_TRUE(ok, false);
+
+    if (!found)
+        return true;
+
+    if (!value.isString()) {
+        JS_ReportErrorASCII(mCx, "Expected a string value for property %s", name);
+        return false;
+    }
+
+    char* tmp = JS_EncodeString(mCx, value.toString());
+    NS_ENSURE_TRUE(tmp, false);
+    prop.Assign(tmp, strlen(tmp));
+    js_free(tmp);
+    return true;
+}
+
+/*
+ * Helper that tries to get a string property from the options object.
+ */
+bool
+OptionsBase::ParseString(const char* name, nsString& prop)
+{
+    RootedValue value(mCx);
+    bool found;
+    bool ok = ParseValue(name, &value, &found);
+    NS_ENSURE_TRUE(ok, false);
+
+    if (!found)
+        return true;
+
+    if (!value.isString()) {
+        JS_ReportErrorASCII(mCx, "Expected a string value for property %s", name);
+        return false;
+    }
+
+    nsAutoJSString strVal;
+    if (!strVal.init(mCx, value.toString()))
+        return false;
+
+    prop = strVal;
+    return true;
+}
+
+/*
+ * Helper that tries to get jsid property from the options object.
+ */
+bool
+OptionsBase::ParseId(const char* name, MutableHandleId prop)
+{
+    RootedValue value(mCx);
+    bool found;
+    bool ok = ParseValue(name, &value, &found);
+    NS_ENSURE_TRUE(ok, false);
+
+    if (!found)
+        return true;
+
+    return JS_ValueToId(mCx, value, prop);
+}
+
+/*
+ * Helper that tries to get a uint32_t property from the options object.
+ */
+bool
+OptionsBase::ParseUInt32(const char* name, uint32_t* prop)
+{
+    MOZ_ASSERT(prop);
+    RootedValue value(mCx);
+    bool found;
+    bool ok = ParseValue(name, &value, &found);
+    NS_ENSURE_TRUE(ok, false);
+
+    if (!found)
+        return true;
+
+    if(!JS::ToUint32(mCx, value, prop)) {
+        JS_ReportErrorASCII(mCx, "Expected a uint32_t value for property %s", name);
+        return false;
+    }
+
+    return true;
+}
+
+/*
+ * Helper that tries to get a list of DOM constructors and other helpers from the options object.
+ */
+bool
+SandboxOptions::ParseGlobalProperties()
+{
+    RootedValue value(mCx);
+    bool found;
+    bool ok = ParseValue("wantGlobalProperties", &value, &found);
+    NS_ENSURE_TRUE(ok, false);
+    if (!found)
+        return true;
+
+    if (!value.isObject()) {
+        JS_ReportErrorASCII(mCx, "Expected an array value for wantGlobalProperties");
+        return false;
+    }
+
+    RootedObject ctors(mCx, &value.toObject());
+    bool isArray;
+    if (!JS_IsArrayObject(mCx, ctors, &isArray))
+        return false;
+    if (!isArray) {
+        JS_ReportErrorASCII(mCx, "Expected an array value for wantGlobalProperties");
+        return false;
+    }
+
+    return globalProperties.Parse(mCx, ctors);
+}
+
+/*
+ * Helper that parsing the sandbox options object (from) and sets the fields of the incoming options struct (options).
+ */
+bool
+SandboxOptions::Parse()
+{
+    /* All option names must be ASCII-only. */
+    bool ok = ParseObject("sandboxPrototype", &proto) &&
+              ParseBoolean("wantXrays", &wantXrays) &&
+              ParseBoolean("allowWaivers", &allowWaivers) &&
+              ParseBoolean("wantComponents", &wantComponents) &&
+              ParseBoolean("wantExportHelpers", &wantExportHelpers) &&
+              ParseBoolean("isWebExtensionContentScript", &isWebExtensionContentScript) &&
+              ParseBoolean("waiveInterposition", &waiveInterposition) &&
+              ParseString("sandboxName", sandboxName) &&
+              ParseObject("sameZoneAs", &sameZoneAs) &&
+              ParseBoolean("freshZone", &freshZone) &&
+              ParseBoolean("invisibleToDebugger", &invisibleToDebugger) &&
+              ParseBoolean("discardSource", &discardSource) &&
+              ParseJSString("addonId", &addonId) &&
+              ParseBoolean("writeToGlobalPrototype", &writeToGlobalPrototype) &&
+              ParseGlobalProperties() &&
+              ParseValue("metadata", &metadata) &&
+              ParseUInt32("userContextId", &userContextId) &&
+              ParseObject("originAttributes", &originAttributes);
+    if (!ok)
+        return false;
+
+    if (freshZone && sameZoneAs) {
+        JS_ReportErrorASCII(mCx, "Cannot use both sameZoneAs and freshZone");
+        return false;
+    }
+
+    return true;
+}
+
+static nsresult
+AssembleSandboxMemoryReporterName(JSContext* cx, nsCString& sandboxName)
+{
+    // Use a default name when the caller did not provide a sandboxName.
+    if (sandboxName.IsEmpty())
+        sandboxName = NS_LITERAL_CSTRING("[anonymous sandbox]");
+
+    nsXPConnect* xpc = nsXPConnect::XPConnect();
+    // Get the xpconnect native call context.
+    nsAXPCNativeCallContext* cc = nullptr;
+    xpc->GetCurrentNativeCallContext(&cc);
+    NS_ENSURE_TRUE(cc, NS_ERROR_INVALID_ARG);
+
+    // Get the current source info from xpc.
+    nsCOMPtr<nsIStackFrame> frame;
+    xpc->GetCurrentJSStack(getter_AddRefs(frame));
+
+    // Append the caller's location information.
+    if (frame) {
+        nsString location;
+        int32_t lineNumber = 0;
+        frame->GetFilename(cx, location);
+        frame->GetLineNumber(cx, &lineNumber);
+
+        sandboxName.AppendLiteral(" (from: ");
+        sandboxName.Append(NS_ConvertUTF16toUTF8(location));
+        sandboxName.Append(':');
+        sandboxName.AppendInt(lineNumber);
+        sandboxName.Append(')');
+    }
+
+    return NS_OK;
+}
+
+// static
+nsresult
+nsXPCComponents_utils_Sandbox::CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
+                                               JSContext* cx, HandleObject obj,
+                                               const CallArgs& args, bool* _retval)
+{
+    if (args.length() < 1)
+        return ThrowAndFail(NS_ERROR_XPC_NOT_ENOUGH_ARGS, cx, _retval);
+
+    nsresult rv;
+    bool ok = false;
+    bool calledWithOptions = args.length() > 1;
+    if (calledWithOptions && !args[1].isObject())
+        return ThrowAndFail(NS_ERROR_INVALID_ARG, cx, _retval);
+
+    RootedObject optionsObject(cx, calledWithOptions ? &args[1].toObject()
+                                                     : nullptr);
+
+    SandboxOptions options(cx, optionsObject);
+    if (calledWithOptions && !options.Parse())
+        return ThrowAndFail(NS_ERROR_INVALID_ARG, cx, _retval);
+
+    // Make sure to set up principals on the sandbox before initing classes.
+    nsCOMPtr<nsIPrincipal> principal;
+    nsCOMPtr<nsIExpandedPrincipal> expanded;
+    nsCOMPtr<nsISupports> prinOrSop;
+
+    if (args[0].isString()) {
+        RootedString str(cx, args[0].toString());
+        PrincipalOriginAttributes attrs;
+        if (options.originAttributes) {
+            JS::RootedValue val(cx, JS::ObjectValue(*options.originAttributes));
+            if (!attrs.Init(cx, val)) {
+                // The originAttributes option, if specified, must be valid!
+                JS_ReportErrorASCII(cx, "Expected a valid OriginAttributes object");
+                return ThrowAndFail(NS_ERROR_INVALID_ARG, cx, _retval);
+            }
+        }
+        attrs.mUserContextId = options.userContextId;
+        ok = ParsePrincipal(cx, str, attrs, getter_AddRefs(principal));
+        prinOrSop = principal;
+    } else if (args[0].isObject()) {
+        RootedObject obj(cx, &args[0].toObject());
+        bool isArray;
+        if (!JS_IsArrayObject(cx, obj, &isArray)) {
+            ok = false;
+        } else if (isArray) {
+            if (options.userContextId != 0) {
+                // We don't support passing a userContextId with an array.
+                ok = false;
+            } else {
+                ok = GetExpandedPrincipal(cx, obj, options, getter_AddRefs(expanded));
+                prinOrSop = expanded;
+            }
+        } else {
+            ok = GetPrincipalOrSOP(cx, obj, getter_AddRefs(prinOrSop));
+        }
+    } else if (args[0].isNull()) {
+        // Null means that we just pass prinOrSop = nullptr, and get an
+        // nsNullPrincipal.
+        ok = true;
+    }
+
+    if (!ok)
+        return ThrowAndFail(NS_ERROR_INVALID_ARG, cx, _retval);
+
+
+    if (NS_FAILED(AssembleSandboxMemoryReporterName(cx, options.sandboxName)))
+        return ThrowAndFail(NS_ERROR_INVALID_ARG, cx, _retval);
+
+    if (options.metadata.isNullOrUndefined()) {
+        // If the caller is running in a sandbox, inherit.
+        RootedObject callerGlobal(cx, CurrentGlobalOrNull(cx));
+        if (IsSandbox(callerGlobal)) {
+            rv = GetSandboxMetadata(cx, callerGlobal, &options.metadata);
+            if (NS_WARN_IF(NS_FAILED(rv)))
+                return rv;
+        }
+    }
+
+    rv = CreateSandboxObject(cx, args.rval(), prinOrSop, options);
+
+    if (NS_FAILED(rv))
+        return ThrowAndFail(rv, cx, _retval);
+
+    // We have this crazy behavior where wantXrays=false also implies that the
+    // returned sandbox is implicitly waived. We've stopped advertising it, but
+    // keep supporting it for now.
+    if (!options.wantXrays && !xpc::WrapperFactory::WaiveXrayAndWrap(cx, args.rval()))
+        return NS_ERROR_UNEXPECTED;
+
+    *_retval = true;
+    return NS_OK;
+}
+
+nsresult
+xpc::EvalInSandbox(JSContext* cx, HandleObject sandboxArg, const nsAString& source,
+                   const nsACString& filename, int32_t lineNo,
+                   JSVersion jsVersion, MutableHandleValue rval)
+{
+    JS_AbortIfWrongThread(cx);
+    rval.set(UndefinedValue());
+
+    bool waiveXray = xpc::WrapperFactory::HasWaiveXrayFlag(sandboxArg);
+    RootedObject sandbox(cx, js::CheckedUnwrap(sandboxArg));
+    if (!sandbox || !IsSandbox(sandbox)) {
+        return NS_ERROR_INVALID_ARG;
+    }
+
+    nsIScriptObjectPrincipal* sop =
+        static_cast<nsIScriptObjectPrincipal*>(xpc_GetJSPrivate(sandbox));
+    MOZ_ASSERT(sop, "Invalid sandbox passed");
+    SandboxPrivate* priv = static_cast<SandboxPrivate*>(sop);
+    nsCOMPtr<nsIPrincipal> prin = sop->GetPrincipal();
+    NS_ENSURE_TRUE(prin, NS_ERROR_FAILURE);
+
+    nsAutoCString filenameBuf;
+    if (!filename.IsVoid() && filename.Length() != 0) {
+        filenameBuf.Assign(filename);
+    } else {
+        // Default to the spec of the principal.
+        nsresult rv = nsJSPrincipals::get(prin)->GetScriptLocation(filenameBuf);
+        NS_ENSURE_SUCCESS(rv, rv);
+        lineNo = 1;
+    }
+
+    // We create a separate cx to do the sandbox evaluation. Scope it.
+    RootedValue v(cx, UndefinedValue());
+    RootedValue exn(cx, UndefinedValue());
+    bool ok = true;
+    {
+        // We're about to evaluate script, so make an AutoEntryScript.
+        // This is clearly Gecko-specific and not in any spec.
+        mozilla::dom::AutoEntryScript aes(priv, "XPConnect sandbox evaluation");
+        JSContext* sandcx = aes.cx();
+        JSAutoCompartment ac(sandcx, sandbox);
+
+        JS::CompileOptions options(sandcx);
+        options.setFileAndLine(filenameBuf.get(), lineNo)
+               .setVersion(jsVersion);
+        MOZ_ASSERT(JS_IsGlobalObject(sandbox));
+        ok = JS::Evaluate(sandcx, options,
+                          PromiseFlatString(source).get(), source.Length(), &v);
+
+        // If the sandbox threw an exception, grab it off the context.
+        if (aes.HasException()) {
+            if (!aes.StealException(&exn)) {
+                return NS_ERROR_OUT_OF_MEMORY;
+            }
+        }
+    }
+
+    //
+    // Alright, we're back on the caller's cx. If an error occured, try to
+    // wrap and set the exception. Otherwise, wrap the return value.
+    //
+
+    if (!ok) {
+        // If we end up without an exception, it was probably due to OOM along
+        // the way, in which case we thow. Otherwise, wrap it.
+        if (exn.isUndefined() || !JS_WrapValue(cx, &exn))
+            return NS_ERROR_OUT_OF_MEMORY;
+
+        // Set the exception on our caller's cx.
+        JS_SetPendingException(cx, exn);
+        return NS_ERROR_FAILURE;
+    }
+
+    // Transitively apply Xray waivers if |sb| was waived.
+    if (waiveXray) {
+        ok = xpc::WrapperFactory::WaiveXrayAndWrap(cx, &v);
+    } else {
+        ok = JS_WrapValue(cx, &v);
+    }
+    NS_ENSURE_TRUE(ok, NS_ERROR_FAILURE);
+
+    // Whew!
+    rval.set(v);
+    return NS_OK;
+}
+
+nsresult
+xpc::GetSandboxAddonId(JSContext* cx, HandleObject sandbox, MutableHandleValue rval)
+{
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(IsSandbox(sandbox));
+
+    JSAddonId* id = JS::AddonIdOfObject(sandbox);
+    if (!id) {
+        rval.setNull();
+        return NS_OK;
+    }
+
+    JS::RootedValue idStr(cx, StringValue(JS::StringOfAddonId(id)));
+    if (!JS_WrapValue(cx, &idStr))
+        return NS_ERROR_UNEXPECTED;
+
+    rval.set(idStr);
+    return NS_OK;
+}
+
+nsresult
+xpc::GetSandboxMetadata(JSContext* cx, HandleObject sandbox, MutableHandleValue rval)
+{
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(IsSandbox(sandbox));
+
+    RootedValue metadata(cx);
+    {
+      JSAutoCompartment ac(cx, sandbox);
+      metadata = JS_GetReservedSlot(sandbox, XPCONNECT_SANDBOX_CLASS_METADATA_SLOT);
+    }
+
+    if (!JS_WrapValue(cx, &metadata))
+        return NS_ERROR_UNEXPECTED;
+
+    rval.set(metadata);
+    return NS_OK;
+}
+
+nsresult
+xpc::SetSandboxMetadata(JSContext* cx, HandleObject sandbox, HandleValue metadataArg)
+{
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(IsSandbox(sandbox));
+
+    RootedValue metadata(cx);
+
+    JSAutoCompartment ac(cx, sandbox);
+    if (!JS_StructuredClone(cx, metadataArg, &metadata, nullptr, nullptr))
+        return NS_ERROR_UNEXPECTED;
+
+    JS_SetReservedSlot(sandbox, XPCONNECT_SANDBOX_CLASS_METADATA_SLOT, metadata);
+
+    return NS_OK;
+}
diff --git a/js/xpconnect/src/SandboxPrivate.h b/js/xpconnect/src/SandboxPrivate.h
new file mode 100644
index 000000000..9f84ec788
--- /dev/null
+++ b/js/xpconnect/src/SandboxPrivate.h
@@ -0,0 +1,67 @@
+/* -*- 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/. */
+
+#ifndef __SANDBOXPRIVATE_H__
+#define __SANDBOXPRIVATE_H__
+
+#include "nsIGlobalObject.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsIPrincipal.h"
+#include "nsWeakReference.h"
+#include "nsWrapperCache.h"
+
+#include "js/RootingAPI.h"
+
+
+class SandboxPrivate : public nsIGlobalObject,
+                       public nsIScriptObjectPrincipal,
+                       public nsSupportsWeakReference,
+                       public nsWrapperCache
+{
+public:
+    SandboxPrivate(nsIPrincipal* principal, JSObject* global)
+        : mPrincipal(principal)
+    {
+        SetIsNotDOMBinding();
+        SetWrapper(global);
+    }
+
+    NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+    NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(SandboxPrivate,
+                                                           nsIGlobalObject)
+
+    nsIPrincipal* GetPrincipal() override
+    {
+        return mPrincipal;
+    }
+
+    JSObject* GetGlobalJSObject() override
+    {
+        return GetWrapper();
+    }
+
+    void ForgetGlobalObject()
+    {
+        ClearWrapper();
+    }
+
+    virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto) override
+    {
+        MOZ_CRASH("SandboxPrivate doesn't use DOM bindings!");
+    }
+
+    void ObjectMoved(JSObject* obj, const JSObject* old)
+    {
+        UpdateWrapper(obj, old);
+    }
+
+private:
+    virtual ~SandboxPrivate() { }
+
+    nsCOMPtr<nsIPrincipal> mPrincipal;
+};
+
+#endif // __SANDBOXPRIVATE_H__
diff --git a/js/xpconnect/src/XPCCallContext.cpp b/js/xpconnect/src/XPCCallContext.cpp
new file mode 100644
index 000000000..22081e3cf
--- /dev/null
+++ b/js/xpconnect/src/XPCCallContext.cpp
@@ -0,0 +1,276 @@
+/* -*- 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/. */
+
+/* Call context. */
+
+#include "xpcprivate.h"
+#include "jswrapper.h"
+#include "jsfriendapi.h"
+#include "nsContentUtils.h"
+
+using namespace mozilla;
+using namespace xpc;
+using namespace JS;
+
+#define IS_TEAROFF_CLASS(clazz) ((clazz) == &XPC_WN_Tearoff_JSClass)
+
+XPCCallContext::XPCCallContext(JSContext* cx,
+                               HandleObject obj    /* = nullptr               */,
+                               HandleObject funobj /* = nullptr               */,
+                               HandleId name       /* = JSID_VOID             */,
+                               unsigned argc       /* = NO_ARGS               */,
+                               Value* argv         /* = nullptr               */,
+                               Value* rval         /* = nullptr               */)
+    :   mAr(cx),
+        mState(INIT_FAILED),
+        mXPC(nsXPConnect::XPConnect()),
+        mXPCJSContext(nullptr),
+        mJSContext(cx),
+        mWrapper(nullptr),
+        mTearOff(nullptr),
+        mName(cx)
+{
+    MOZ_ASSERT(cx);
+    MOZ_ASSERT(cx == nsContentUtils::GetCurrentJSContext());
+
+    if (!mXPC)
+        return;
+
+    mXPCJSContext = XPCJSContext::Get();
+
+    // hook into call context chain.
+    mPrevCallContext = mXPCJSContext->SetCallContext(this);
+
+    mState = HAVE_CONTEXT;
+
+    if (!obj)
+        return;
+
+    mMethodIndex = 0xDEAD;
+
+    mState = HAVE_OBJECT;
+
+    mTearOff = nullptr;
+
+    JSObject* unwrapped = js::CheckedUnwrap(obj, /* stopAtWindowProxy = */ false);
+    if (!unwrapped) {
+        JS_ReportErrorASCII(mJSContext, "Permission denied to call method on |this|");
+        mState = INIT_FAILED;
+        return;
+    }
+    const js::Class* clasp = js::GetObjectClass(unwrapped);
+    if (IS_WN_CLASS(clasp)) {
+        mWrapper = XPCWrappedNative::Get(unwrapped);
+    } else if (IS_TEAROFF_CLASS(clasp)) {
+        mTearOff = (XPCWrappedNativeTearOff*)js::GetObjectPrivate(unwrapped);
+        mWrapper = XPCWrappedNative::Get(
+          &js::GetReservedSlot(unwrapped,
+                               XPC_WN_TEAROFF_FLAT_OBJECT_SLOT).toObject());
+    }
+    if (mWrapper) {
+        if (mTearOff)
+            mScriptableInfo = nullptr;
+        else
+            mScriptableInfo = mWrapper->GetScriptableInfo();
+    }
+
+    if (!JSID_IS_VOID(name))
+        SetName(name);
+
+    if (argc != NO_ARGS)
+        SetArgsAndResultPtr(argc, argv, rval);
+
+    CHECK_STATE(HAVE_OBJECT);
+}
+
+void
+XPCCallContext::SetName(jsid name)
+{
+    CHECK_STATE(HAVE_OBJECT);
+
+    mName = name;
+
+    if (mTearOff) {
+        mSet = nullptr;
+        mInterface = mTearOff->GetInterface();
+        mMember = mInterface->FindMember(mName);
+        mStaticMemberIsLocal = true;
+        if (mMember && !mMember->IsConstant())
+            mMethodIndex = mMember->GetIndex();
+    } else {
+        mSet = mWrapper ? mWrapper->GetSet() : nullptr;
+
+        if (mSet &&
+            mSet->FindMember(mName, &mMember, &mInterface,
+                             mWrapper->HasProto() ?
+                             mWrapper->GetProto()->GetSet() :
+                             nullptr,
+                             &mStaticMemberIsLocal)) {
+            if (mMember && !mMember->IsConstant())
+                mMethodIndex = mMember->GetIndex();
+        } else {
+            mMember = nullptr;
+            mInterface = nullptr;
+            mStaticMemberIsLocal = false;
+        }
+    }
+
+    mState = HAVE_NAME;
+}
+
+void
+XPCCallContext::SetCallInfo(XPCNativeInterface* iface, XPCNativeMember* member,
+                            bool isSetter)
+{
+    CHECK_STATE(HAVE_CONTEXT);
+
+    // We are going straight to the method info and need not do a lookup
+    // by id.
+
+    // don't be tricked if method is called with wrong 'this'
+    if (mTearOff && mTearOff->GetInterface() != iface)
+        mTearOff = nullptr;
+
+    mSet = nullptr;
+    mInterface = iface;
+    mMember = member;
+    mMethodIndex = mMember->GetIndex() + (isSetter ? 1 : 0);
+    mName = mMember->GetName();
+
+    if (mState < HAVE_NAME)
+        mState = HAVE_NAME;
+}
+
+void
+XPCCallContext::SetArgsAndResultPtr(unsigned argc,
+                                    Value* argv,
+                                    Value* rval)
+{
+    CHECK_STATE(HAVE_OBJECT);
+
+    if (mState < HAVE_NAME) {
+        mSet = nullptr;
+        mInterface = nullptr;
+        mMember = nullptr;
+        mStaticMemberIsLocal = false;
+    }
+
+    mArgc   = argc;
+    mArgv   = argv;
+    mRetVal = rval;
+
+    mState = HAVE_ARGS;
+}
+
+nsresult
+XPCCallContext::CanCallNow()
+{
+    nsresult rv;
+
+    if (!HasInterfaceAndMember())
+        return NS_ERROR_UNEXPECTED;
+    if (mState < HAVE_ARGS)
+        return NS_ERROR_UNEXPECTED;
+
+    if (!mTearOff) {
+        mTearOff = mWrapper->FindTearOff(mInterface, false, &rv);
+        if (!mTearOff || mTearOff->GetInterface() != mInterface) {
+            mTearOff = nullptr;
+            return NS_FAILED(rv) ? rv : NS_ERROR_UNEXPECTED;
+        }
+    }
+
+    // Refresh in case FindTearOff extended the set
+    mSet = mWrapper->GetSet();
+
+    mState = READY_TO_CALL;
+    return NS_OK;
+}
+
+void
+XPCCallContext::SystemIsBeingShutDown()
+{
+    // XXX This is pretty questionable since the per thread cleanup stuff
+    // can be making this call on one thread for call contexts on another
+    // thread.
+    NS_WARNING("Shutting Down XPConnect even through there is a live XPCCallContext");
+    mXPCJSContext = nullptr;
+    mState = SYSTEM_SHUTDOWN;
+    mSet = nullptr;
+    mInterface = nullptr;
+
+    if (mPrevCallContext)
+        mPrevCallContext->SystemIsBeingShutDown();
+}
+
+XPCCallContext::~XPCCallContext()
+{
+    if (mXPCJSContext) {
+        DebugOnly<XPCCallContext*> old = mXPCJSContext->SetCallContext(mPrevCallContext);
+        MOZ_ASSERT(old == this, "bad pop from per thread data");
+    }
+}
+
+NS_IMETHODIMP
+XPCCallContext::GetCallee(nsISupports * *aCallee)
+{
+    nsCOMPtr<nsISupports> rval = mWrapper ? mWrapper->GetIdentityObject() : nullptr;
+    rval.forget(aCallee);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XPCCallContext::GetCalleeMethodIndex(uint16_t* aCalleeMethodIndex)
+{
+    *aCalleeMethodIndex = mMethodIndex;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XPCCallContext::GetCalleeInterface(nsIInterfaceInfo * *aCalleeInterface)
+{
+    nsCOMPtr<nsIInterfaceInfo> rval = mInterface->GetInterfaceInfo();
+    rval.forget(aCalleeInterface);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XPCCallContext::GetCalleeClassInfo(nsIClassInfo * *aCalleeClassInfo)
+{
+    nsCOMPtr<nsIClassInfo> rval = mWrapper ? mWrapper->GetClassInfo() : nullptr;
+    rval.forget(aCalleeClassInfo);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XPCCallContext::GetJSContext(JSContext * *aJSContext)
+{
+    JS_AbortIfWrongThread(mJSContext);
+    *aJSContext = mJSContext;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XPCCallContext::GetArgc(uint32_t* aArgc)
+{
+    *aArgc = (uint32_t) mArgc;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XPCCallContext::GetArgvPtr(Value** aArgvPtr)
+{
+    *aArgvPtr = mArgv;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+XPCCallContext::GetPreviousCallContext(nsAXPCNativeCallContext** aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = GetPrevCallContext();
+  return NS_OK;
+}
diff --git a/js/xpconnect/src/XPCComponents.cpp b/js/xpconnect/src/XPCComponents.cpp
new file mode 100644
index 000000000..ca78234c9
--- /dev/null
+++ b/js/xpconnect/src/XPCComponents.cpp
@@ -0,0 +1,3563 @@
+/* -*- 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/. */
+
+/* The "Components" xpcom objects for JavaScript. */
+
+#include "xpcprivate.h"
+#include "xpc_make_class.h"
+#include "xpcIJSModuleLoader.h"
+#include "XPCJSWeakReference.h"
+#include "WrapperFactory.h"
+#include "nsJSUtils.h"
+#include "mozJSComponentLoader.h"
+#include "nsContentUtils.h"
+#include "nsCycleCollector.h"
+#include "jsfriendapi.h"
+#include "js/StructuredClone.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
+#include "mozilla/Preferences.h"
+#include "nsJSEnvironment.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/XPTInterfaceInfoManager.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/DOMExceptionBinding.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/StructuredCloneTags.h"
+#include "mozilla/dom/WindowBinding.h"
+#include "nsZipArchive.h"
+#include "nsIDOMFileList.h"
+#include "nsWindowMemoryReporter.h"
+#include "nsDOMClassInfo.h"
+#include "ShimInterfaceInfo.h"
+#include "nsIAddonInterposition.h"
+#include "nsISimpleEnumerator.h"
+#include "nsPIDOMWindow.h"
+#include "nsGlobalWindow.h"
+
+using namespace mozilla;
+using namespace JS;
+using namespace js;
+using namespace xpc;
+using mozilla::dom::Exception;
+
+/***************************************************************************/
+// stuff used by all
+
+nsresult
+xpc::ThrowAndFail(nsresult errNum, JSContext* cx, bool* retval)
+{
+    XPCThrower::Throw(errNum, cx);
+    *retval = false;
+    return NS_OK;
+}
+
+static bool
+JSValIsInterfaceOfType(JSContext* cx, HandleValue v, REFNSIID iid)
+{
+
+    nsCOMPtr<nsIXPConnectWrappedNative> wn;
+    nsCOMPtr<nsISupports> iface;
+
+    if (v.isPrimitive())
+        return false;
+
+    nsXPConnect* xpc = nsXPConnect::XPConnect();
+    RootedObject obj(cx, &v.toObject());
+    return NS_SUCCEEDED(xpc->GetWrappedNativeOfJSObject(cx, obj, getter_AddRefs(wn))) && wn &&
+        NS_SUCCEEDED(wn->Native()->QueryInterface(iid, getter_AddRefs(iface))) && iface;
+}
+
+char*
+xpc::CloneAllAccess()
+{
+    static const char allAccess[] = "AllAccess";
+    return (char*)nsMemory::Clone(allAccess, sizeof(allAccess));
+}
+
+char*
+xpc::CheckAccessList(const char16_t* wideName, const char* const list[])
+{
+    nsAutoCString asciiName;
+    CopyUTF16toUTF8(nsDependentString(wideName), asciiName);
+
+    for (const char* const* p = list; *p; p++)
+        if (!strcmp(*p, asciiName.get()))
+            return CloneAllAccess();
+
+    return nullptr;
+}
+
+/***************************************************************************/
+/***************************************************************************/
+/***************************************************************************/
+
+
+class nsXPCComponents_Interfaces final :
+            public nsIXPCComponents_Interfaces,
+            public nsIXPCScriptable,
+            public nsIClassInfo
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTS_INTERFACES
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSICLASSINFO
+
+public:
+    nsXPCComponents_Interfaces();
+
+private:
+    virtual ~nsXPCComponents_Interfaces();
+
+    nsCOMArray<nsIInterfaceInfo> mInterfaces;
+};
+
+NS_IMETHODIMP
+nsXPCComponents_Interfaces::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCComponents_Interfaces)
+    PUSH_IID(nsIXPCScriptable)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Interfaces::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    *retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Interfaces::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Interfaces::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "XPCComponents_Interfaces";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Interfaces::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Interfaces::GetFlags(uint32_t* aFlags)
+{
+    // Mark ourselves as a DOM object so that instances may be created in
+    // unprivileged scopes.
+    *aFlags = nsIClassInfo::DOM_OBJECT;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Interfaces::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsXPCComponents_Interfaces::nsXPCComponents_Interfaces()
+{
+}
+
+nsXPCComponents_Interfaces::~nsXPCComponents_Interfaces()
+{
+    // empty
+}
+
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_Interfaces)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_Interfaces)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_Interfaces)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_Interfaces)
+NS_IMPL_RELEASE(nsXPCComponents_Interfaces)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCComponents_Interfaces
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_Interfaces"
+#define                             XPC_MAP_WANT_RESOLVE
+#define                             XPC_MAP_WANT_NEWENUMERATE
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+
+NS_IMETHODIMP
+nsXPCComponents_Interfaces::NewEnumerate(nsIXPConnectWrappedNative* wrapper,
+                                         JSContext* cx, JSObject* obj,
+                                         JS::AutoIdVector& properties,
+                                         bool* _retval)
+{
+
+    // Lazily init the list of interfaces when someone tries to
+    // enumerate them.
+    if (mInterfaces.IsEmpty()) {
+        XPTInterfaceInfoManager::GetSingleton()->
+            GetScriptableInterfaces(mInterfaces);
+    }
+
+    if (!properties.reserve(mInterfaces.Length())) {
+        *_retval = false;
+        return NS_OK;
+    }
+
+    for (uint32_t index = 0; index < mInterfaces.Length(); index++) {
+        nsIInterfaceInfo* interface = mInterfaces.SafeElementAt(index);
+        if (!interface)
+            continue;
+
+        const char* name;
+        if (NS_SUCCEEDED(interface->GetNameShared(&name)) && name) {
+            RootedString idstr(cx, JS_NewStringCopyZ(cx, name));
+            if (!idstr) {
+                *_retval = false;
+                return NS_OK;
+            }
+
+            RootedId id(cx);
+            if (!JS_StringToId(cx, idstr, &id)) {
+                *_retval = false;
+                return NS_OK;
+            }
+
+            properties.infallibleAppend(id);
+        }
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Interfaces::Resolve(nsIXPConnectWrappedNative* wrapper,
+                                    JSContext* cx, JSObject* objArg,
+                                    jsid idArg, bool* resolvedp,
+                                    bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    RootedId id(cx, idArg);
+
+    if (!JSID_IS_STRING(id))
+        return NS_OK;
+
+    JSAutoByteString name;
+    RootedString str(cx, JSID_TO_STRING(id));
+
+    // we only allow interfaces by name here
+    if (name.encodeLatin1(cx, str) && name.ptr()[0] != '{') {
+        nsCOMPtr<nsIInterfaceInfo> info =
+            ShimInterfaceInfo::MaybeConstruct(name.ptr(), cx);
+        if (!info) {
+            XPTInterfaceInfoManager::GetSingleton()->
+                GetInfoForName(name.ptr(), getter_AddRefs(info));
+        }
+        if (!info)
+            return NS_OK;
+
+        nsCOMPtr<nsIJSIID> nsid = nsJSIID::NewID(info);
+
+        if (nsid) {
+            nsXPConnect* xpc = nsXPConnect::XPConnect();
+            RootedObject idobj(cx);
+            if (NS_SUCCEEDED(xpc->WrapNative(cx, obj,
+                                             static_cast<nsIJSIID*>(nsid),
+                                             NS_GET_IID(nsIJSIID),
+                                             idobj.address()))) {
+                if (idobj) {
+                    *resolvedp = true;
+                    *_retval = JS_DefinePropertyById(cx, obj, id, idobj,
+                                                     JSPROP_ENUMERATE |
+                                                     JSPROP_READONLY |
+                                                     JSPROP_PERMANENT |
+                                                     JSPROP_RESOLVING);
+                }
+            }
+        }
+    }
+    return NS_OK;
+}
+
+/***************************************************************************/
+/***************************************************************************/
+/***************************************************************************/
+
+class nsXPCComponents_InterfacesByID final :
+            public nsIXPCComponents_InterfacesByID,
+            public nsIXPCScriptable,
+            public nsIClassInfo
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTS_INTERFACESBYID
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSICLASSINFO
+
+public:
+    nsXPCComponents_InterfacesByID();
+
+private:
+    virtual ~nsXPCComponents_InterfacesByID();
+
+    nsCOMArray<nsIInterfaceInfo> mInterfaces;
+};
+
+/***************************************************************************/
+NS_IMETHODIMP
+nsXPCComponents_InterfacesByID::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCComponents_InterfacesByID)
+    PUSH_IID(nsIXPCScriptable)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_InterfacesByID::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    *retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_InterfacesByID::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_InterfacesByID::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "XPCComponents_InterfacesByID";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_InterfacesByID::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_InterfacesByID::GetFlags(uint32_t* aFlags)
+{
+    // Mark ourselves as a DOM object so that instances may be created in
+    // unprivileged scopes.
+    *aFlags = nsIClassInfo::DOM_OBJECT;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_InterfacesByID::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsXPCComponents_InterfacesByID::nsXPCComponents_InterfacesByID()
+{
+}
+
+nsXPCComponents_InterfacesByID::~nsXPCComponents_InterfacesByID()
+{
+    // empty
+}
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_InterfacesByID)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_InterfacesByID)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_InterfacesByID)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_InterfacesByID)
+NS_IMPL_RELEASE(nsXPCComponents_InterfacesByID)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCComponents_InterfacesByID
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_InterfacesByID"
+#define                             XPC_MAP_WANT_RESOLVE
+#define                             XPC_MAP_WANT_NEWENUMERATE
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+NS_IMETHODIMP
+nsXPCComponents_InterfacesByID::NewEnumerate(nsIXPConnectWrappedNative* wrapper,
+                                             JSContext* cx, JSObject* obj,
+                                             JS::AutoIdVector& properties,
+                                             bool* _retval)
+{
+
+    if (mInterfaces.IsEmpty()) {
+        XPTInterfaceInfoManager::GetSingleton()->
+            GetScriptableInterfaces(mInterfaces);
+    }
+
+    if (!properties.reserve(mInterfaces.Length())) {
+        *_retval = false;
+        return NS_OK;
+    }
+
+    for (uint32_t index = 0; index < mInterfaces.Length(); index++) {
+        nsIInterfaceInfo* interface = mInterfaces.SafeElementAt(index);
+        if (!interface)
+            continue;
+
+        nsIID const* iid;
+        if (NS_SUCCEEDED(interface->GetIIDShared(&iid))) {
+            char idstr[NSID_LENGTH];
+            iid->ToProvidedString(idstr);
+            RootedString jsstr(cx, JS_NewStringCopyZ(cx, idstr));
+            if (!jsstr) {
+                *_retval = false;
+                return NS_OK;
+            }
+
+            RootedId id(cx);
+            if (!JS_StringToId(cx, jsstr, &id)) {
+                *_retval = false;
+                return NS_OK;
+            }
+
+            properties.infallibleAppend(id);
+        }
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_InterfacesByID::Resolve(nsIXPConnectWrappedNative* wrapper,
+                                        JSContext* cx, JSObject* objArg,
+                                        jsid idArg, bool* resolvedp,
+                                        bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    RootedId id(cx, idArg);
+
+    if (!JSID_IS_STRING(id))
+        return NS_OK;
+
+    RootedString str(cx, JSID_TO_STRING(id));
+    if (38 != JS_GetStringLength(str))
+        return NS_OK;
+
+    JSAutoByteString utf8str;
+    if (utf8str.encodeUtf8(cx, str)) {
+        nsID iid;
+        if (!iid.Parse(utf8str.ptr()))
+            return NS_OK;
+
+        nsCOMPtr<nsIInterfaceInfo> info;
+        XPTInterfaceInfoManager::GetSingleton()->
+            GetInfoForIID(&iid, getter_AddRefs(info));
+        if (!info)
+            return NS_OK;
+
+        nsCOMPtr<nsIJSIID> nsid = nsJSIID::NewID(info);
+
+        if (!nsid)
+            return NS_ERROR_OUT_OF_MEMORY;
+
+        nsXPConnect* xpc = nsXPConnect::XPConnect();
+        RootedObject idobj(cx);
+        if (NS_SUCCEEDED(xpc->WrapNative(cx, obj,
+                                         static_cast<nsIJSIID*>(nsid),
+                                         NS_GET_IID(nsIJSIID),
+                                         idobj.address()))) {
+            if (idobj) {
+                *resolvedp = true;
+                *_retval =
+                    JS_DefinePropertyById(cx, obj, id, idobj,
+                                          JSPROP_ENUMERATE |
+                                          JSPROP_READONLY |
+                                          JSPROP_PERMANENT |
+                                          JSPROP_RESOLVING);
+            }
+        }
+    }
+    return NS_OK;
+}
+
+/***************************************************************************/
+/***************************************************************************/
+/***************************************************************************/
+
+
+
+class nsXPCComponents_Classes final :
+  public nsIXPCComponents_Classes,
+  public nsIXPCScriptable,
+  public nsIClassInfo
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTS_CLASSES
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSICLASSINFO
+
+public:
+    nsXPCComponents_Classes();
+
+private:
+    virtual ~nsXPCComponents_Classes();
+};
+
+/***************************************************************************/
+NS_IMETHODIMP
+nsXPCComponents_Classes::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCComponents_Classes)
+    PUSH_IID(nsIXPCScriptable)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Classes::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    *retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Classes::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Classes::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "XPCComponents_Classes";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Classes::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Classes::GetFlags(uint32_t* aFlags)
+{
+    *aFlags = 0;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Classes::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsXPCComponents_Classes::nsXPCComponents_Classes()
+{
+}
+
+nsXPCComponents_Classes::~nsXPCComponents_Classes()
+{
+    // empty
+}
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_Classes)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_Classes)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_Classes)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_Classes)
+NS_IMPL_RELEASE(nsXPCComponents_Classes)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCComponents_Classes
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_Classes"
+#define                             XPC_MAP_WANT_RESOLVE
+#define                             XPC_MAP_WANT_NEWENUMERATE
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+NS_IMETHODIMP
+nsXPCComponents_Classes::NewEnumerate(nsIXPConnectWrappedNative* wrapper,
+                                      JSContext* cx, JSObject* obj,
+                                      JS::AutoIdVector& properties,
+                                      bool* _retval)
+{
+    nsCOMPtr<nsIComponentRegistrar> compMgr;
+    if (NS_FAILED(NS_GetComponentRegistrar(getter_AddRefs(compMgr))) || !compMgr)
+        return NS_ERROR_UNEXPECTED;
+
+    nsCOMPtr<nsISimpleEnumerator> e;
+    if (NS_FAILED(compMgr->EnumerateContractIDs(getter_AddRefs(e))) || !e)
+        return NS_ERROR_UNEXPECTED;
+
+    bool hasMore;
+    nsCOMPtr<nsISupports> isup;
+    while(NS_SUCCEEDED(e->HasMoreElements(&hasMore)) && hasMore &&
+          NS_SUCCEEDED(e->GetNext(getter_AddRefs(isup))) && isup) {
+        nsCOMPtr<nsISupportsCString> holder(do_QueryInterface(isup));
+        if (!holder)
+            continue;
+
+        nsAutoCString name;
+        if (NS_SUCCEEDED(holder->GetData(name))) {
+            RootedString idstr(cx, JS_NewStringCopyN(cx, name.get(), name.Length()));
+            if (!idstr) {
+                *_retval = false;
+                return NS_OK;
+            }
+
+            RootedId id(cx);
+            if (!JS_StringToId(cx, idstr, &id)) {
+                *_retval = false;
+                return NS_OK;
+            }
+
+            if (!properties.append(id)) {
+                *_retval = false;
+                return NS_OK;
+            }
+        }
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Classes::Resolve(nsIXPConnectWrappedNative* wrapper,
+                                 JSContext* cx, JSObject* objArg,
+                                 jsid idArg, bool* resolvedp,
+                                 bool* _retval)
+
+{
+    RootedId id(cx, idArg);
+    RootedObject obj(cx, objArg);
+
+    JSAutoByteString name;
+    if (JSID_IS_STRING(id) &&
+        name.encodeLatin1(cx, JSID_TO_STRING(id)) &&
+        name.ptr()[0] != '{') { // we only allow contractids here
+        nsCOMPtr<nsIJSCID> nsid = nsJSCID::NewID(name.ptr());
+        if (nsid) {
+            nsXPConnect* xpc = nsXPConnect::XPConnect();
+            RootedObject idobj(cx);
+            if (NS_SUCCEEDED(xpc->WrapNative(cx, obj,
+                                             static_cast<nsIJSCID*>(nsid),
+                                             NS_GET_IID(nsIJSCID),
+                                             idobj.address()))) {
+                if (idobj) {
+                    *resolvedp = true;
+                    *_retval = JS_DefinePropertyById(cx, obj, id, idobj,
+                                                     JSPROP_ENUMERATE |
+                                                     JSPROP_READONLY |
+                                                     JSPROP_PERMANENT |
+                                                     JSPROP_RESOLVING);
+                }
+            }
+        }
+    }
+    return NS_OK;
+}
+
+/***************************************************************************/
+/***************************************************************************/
+/***************************************************************************/
+
+class nsXPCComponents_ClassesByID final :
+  public nsIXPCComponents_ClassesByID,
+  public nsIXPCScriptable,
+  public nsIClassInfo
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTS_CLASSESBYID
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSICLASSINFO
+
+public:
+    nsXPCComponents_ClassesByID();
+
+private:
+    virtual ~nsXPCComponents_ClassesByID();
+};
+
+/***************************************************************************/
+NS_IMETHODIMP
+nsXPCComponents_ClassesByID::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCComponents_ClassesByID)
+    PUSH_IID(nsIXPCScriptable)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ClassesByID::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    *retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ClassesByID::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ClassesByID::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "XPCComponents_ClassesByID";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ClassesByID::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ClassesByID::GetFlags(uint32_t* aFlags)
+{
+    *aFlags = 0;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ClassesByID::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsXPCComponents_ClassesByID::nsXPCComponents_ClassesByID()
+{
+}
+
+nsXPCComponents_ClassesByID::~nsXPCComponents_ClassesByID()
+{
+    // empty
+}
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_ClassesByID)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_ClassesByID)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_ClassesByID)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_ClassesByID)
+NS_IMPL_RELEASE(nsXPCComponents_ClassesByID)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCComponents_ClassesByID
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_ClassesByID"
+#define                             XPC_MAP_WANT_RESOLVE
+#define                             XPC_MAP_WANT_NEWENUMERATE
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+NS_IMETHODIMP
+nsXPCComponents_ClassesByID::NewEnumerate(nsIXPConnectWrappedNative* wrapper,
+                                          JSContext* cx, JSObject* obj,
+                                          JS::AutoIdVector& properties,
+                                          bool* _retval)
+{
+
+    nsCOMPtr<nsIComponentRegistrar> compMgr;
+    if (NS_FAILED(NS_GetComponentRegistrar(getter_AddRefs(compMgr))) || !compMgr)
+        return NS_ERROR_UNEXPECTED;
+
+    nsISimpleEnumerator* e;
+    if (NS_FAILED(compMgr->EnumerateCIDs(&e)) || !e)
+        return NS_ERROR_UNEXPECTED;
+
+    bool hasMore;
+    nsCOMPtr<nsISupports> isup;
+    while(NS_SUCCEEDED(e->HasMoreElements(&hasMore)) && hasMore &&
+          NS_SUCCEEDED(e->GetNext(getter_AddRefs(isup))) && isup) {
+        nsCOMPtr<nsISupportsID> holder(do_QueryInterface(isup));
+        if (!holder)
+            continue;
+
+        char* name;
+        if (NS_SUCCEEDED(holder->ToString(&name)) && name) {
+            RootedString idstr(cx, JS_NewStringCopyZ(cx, name));
+            if (!idstr) {
+                *_retval = false;
+                return NS_OK;
+            }
+
+            RootedId id(cx);
+            if (!JS_StringToId(cx, idstr, &id)) {
+                *_retval = false;
+                return NS_OK;
+            }
+
+            if (!properties.append(id)) {
+                *_retval = false;
+                return NS_OK;
+            }
+        }
+    }
+
+    return NS_OK;
+}
+
+static bool
+IsRegisteredCLSID(const char* str)
+{
+    bool registered;
+    nsID id;
+
+    if (!id.Parse(str))
+        return false;
+
+    nsCOMPtr<nsIComponentRegistrar> compMgr;
+    if (NS_FAILED(NS_GetComponentRegistrar(getter_AddRefs(compMgr))) || !compMgr ||
+        NS_FAILED(compMgr->IsCIDRegistered(id, &registered)))
+        return false;
+
+    return registered;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ClassesByID::Resolve(nsIXPConnectWrappedNative* wrapper,
+                                     JSContext* cx, JSObject* objArg,
+                                     jsid idArg, bool* resolvedp,
+                                     bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    RootedId id(cx, idArg);
+
+    if (!JSID_IS_STRING(id))
+        return NS_OK;
+
+    JSAutoByteString name;
+    RootedString str(cx, JSID_TO_STRING(id));
+    if (name.encodeLatin1(cx, str) && name.ptr()[0] == '{' &&
+        IsRegisteredCLSID(name.ptr())) // we only allow canonical CLSIDs here
+    {
+        nsCOMPtr<nsIJSCID> nsid = nsJSCID::NewID(name.ptr());
+        if (nsid) {
+            nsXPConnect* xpc = nsXPConnect::XPConnect();
+            RootedObject idobj(cx);
+            if (NS_SUCCEEDED(xpc->WrapNative(cx, obj,
+                                             static_cast<nsIJSCID*>(nsid),
+                                             NS_GET_IID(nsIJSCID),
+                                             idobj.address()))) {
+                if (idobj) {
+                    *resolvedp = true;
+                    *_retval = JS_DefinePropertyById(cx, obj, id, idobj,
+                                                     JSPROP_ENUMERATE |
+                                                     JSPROP_READONLY |
+                                                     JSPROP_PERMANENT |
+                                                     JSPROP_RESOLVING);
+                }
+            }
+        }
+    }
+    return NS_OK;
+}
+
+
+/***************************************************************************/
+
+// Currently the possible results do not change at runtime, so they are only
+// cached once (unlike ContractIDs, CLSIDs, and IIDs)
+
+class nsXPCComponents_Results final :
+  public nsIXPCComponents_Results,
+  public nsIXPCScriptable,
+  public nsIClassInfo
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTS_RESULTS
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSICLASSINFO
+
+public:
+    nsXPCComponents_Results();
+
+private:
+    virtual ~nsXPCComponents_Results();
+};
+
+/***************************************************************************/
+NS_IMETHODIMP
+nsXPCComponents_Results::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCComponents_Results)
+    PUSH_IID(nsIXPCScriptable)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Results::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    *retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Results::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Results::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "XPCComponents_Results";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Results::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Results::GetFlags(uint32_t* aFlags)
+{
+    // Mark ourselves as a DOM object so that instances may be created in
+    // unprivileged scopes.
+    *aFlags = nsIClassInfo::DOM_OBJECT;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Results::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsXPCComponents_Results::nsXPCComponents_Results()
+{
+}
+
+nsXPCComponents_Results::~nsXPCComponents_Results()
+{
+    // empty
+}
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_Results)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_Results)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_Results)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_Results)
+NS_IMPL_RELEASE(nsXPCComponents_Results)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCComponents_Results
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_Results"
+#define                             XPC_MAP_WANT_RESOLVE
+#define                             XPC_MAP_WANT_NEWENUMERATE
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+NS_IMETHODIMP
+nsXPCComponents_Results::NewEnumerate(nsIXPConnectWrappedNative* wrapper,
+                                      JSContext* cx, JSObject* obj,
+                                      JS::AutoIdVector& properties,
+                                      bool* _retval)
+{
+    const char* name;
+    const void* iter = nullptr;
+    while (nsXPCException::IterateNSResults(nullptr, &name, nullptr, &iter)) {
+        RootedString idstr(cx, JS_NewStringCopyZ(cx, name));
+        if (!idstr) {
+            *_retval = false;
+            return NS_OK;
+        }
+
+        RootedId id(cx);
+        if (!JS_StringToId(cx, idstr, &id)) {
+            *_retval = false;
+            return NS_OK;
+        }
+
+        if (!properties.append(id)) {
+            *_retval = false;
+            return NS_OK;
+        }
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Results::Resolve(nsIXPConnectWrappedNative* wrapper,
+                                 JSContext* cx, JSObject* objArg,
+                                 jsid idArg, bool* resolvedp,
+                                 bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    RootedId id(cx, idArg);
+    JSAutoByteString name;
+
+    if (JSID_IS_STRING(id) && name.encodeLatin1(cx, JSID_TO_STRING(id))) {
+        const char* rv_name;
+        const void* iter = nullptr;
+        nsresult rv;
+        while (nsXPCException::IterateNSResults(&rv, &rv_name, nullptr, &iter)) {
+            if (!strcmp(name.ptr(), rv_name)) {
+                *resolvedp = true;
+                if (!JS_DefinePropertyById(cx, obj, id, (uint32_t)rv,
+                                           JSPROP_ENUMERATE |
+                                           JSPROP_READONLY |
+                                           JSPROP_PERMANENT |
+                                           JSPROP_RESOLVING)) {
+                    return NS_ERROR_UNEXPECTED;
+                }
+            }
+        }
+    }
+    return NS_OK;
+}
+
+/***************************************************************************/
+// JavaScript Constructor for nsIJSID objects (Components.ID)
+
+class nsXPCComponents_ID final :
+  public nsIXPCComponents_ID,
+  public nsIXPCScriptable,
+  public nsIClassInfo
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTS_ID
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSICLASSINFO
+
+
+public:
+    nsXPCComponents_ID();
+
+private:
+    virtual ~nsXPCComponents_ID();
+    static nsresult CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
+                                    JSContext* cx, HandleObject obj,
+                                    const CallArgs& args, bool* _retval);
+};
+
+/***************************************************************************/
+NS_IMETHODIMP
+nsXPCComponents_ID::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCComponents_ID)
+    PUSH_IID(nsIXPCScriptable)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ID::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    *retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ID::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ID::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "XPCComponents_ID";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ID::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ID::GetFlags(uint32_t* aFlags)
+{
+    *aFlags = 0;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ID::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsXPCComponents_ID::nsXPCComponents_ID()
+{
+}
+
+nsXPCComponents_ID::~nsXPCComponents_ID()
+{
+    // empty
+}
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_ID)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_ID)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_ID)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_ID)
+NS_IMPL_RELEASE(nsXPCComponents_ID)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCComponents_ID
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_ID"
+#define                             XPC_MAP_WANT_CALL
+#define                             XPC_MAP_WANT_CONSTRUCT
+#define                             XPC_MAP_WANT_HASINSTANCE
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+
+NS_IMETHODIMP
+nsXPCComponents_ID::Call(nsIXPConnectWrappedNative* wrapper, JSContext* cx, JSObject* objArg,
+                         const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ID::Construct(nsIXPConnectWrappedNative* wrapper, JSContext* cx, JSObject* objArg,
+                              const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+}
+
+// static
+nsresult
+nsXPCComponents_ID::CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
+                                    JSContext* cx, HandleObject obj,
+                                    const CallArgs& args, bool* _retval)
+{
+    // make sure we have at least one arg
+
+    if (args.length() < 1)
+        return ThrowAndFail(NS_ERROR_XPC_NOT_ENOUGH_ARGS, cx, _retval);
+
+    // Do the security check if necessary
+
+    if (NS_FAILED(nsXPConnect::SecurityManager()->CanCreateInstance(cx, nsJSID::GetCID()))) {
+        // the security manager vetoed. It should have set an exception.
+        *_retval = false;
+        return NS_OK;
+    }
+
+    // convert the first argument into a string and see if it looks like an id
+
+    JSString* jsstr;
+    JSAutoByteString bytes;
+    nsID id;
+
+    if (!(jsstr = ToString(cx, args[0])) ||
+        !bytes.encodeLatin1(cx, jsstr) ||
+        !id.Parse(bytes.ptr())) {
+        return ThrowAndFail(NS_ERROR_XPC_BAD_ID_STRING, cx, _retval);
+    }
+
+    // make the new object and return it.
+
+    JSObject* newobj = xpc_NewIDObject(cx, obj, id);
+    if (!newobj)
+        return NS_ERROR_UNEXPECTED;
+
+    args.rval().setObject(*newobj);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_ID::HasInstance(nsIXPConnectWrappedNative* wrapper,
+                                JSContext* cx, JSObject* obj,
+                                HandleValue val, bool* bp, bool* _retval)
+{
+    if (bp)
+        *bp = JSValIsInterfaceOfType(cx, val, NS_GET_IID(nsIJSID));
+    return NS_OK;
+}
+
+/***************************************************************************/
+// JavaScript Constructor for nsIXPCException objects (Components.Exception)
+
+class nsXPCComponents_Exception final :
+  public nsIXPCComponents_Exception,
+  public nsIXPCScriptable,
+  public nsIClassInfo
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTS_EXCEPTION
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSICLASSINFO
+
+
+public:
+    nsXPCComponents_Exception();
+
+private:
+    virtual ~nsXPCComponents_Exception();
+    static nsresult CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
+                                    JSContext* cx, HandleObject obj,
+                                    const CallArgs& args, bool* _retval);
+};
+
+/***************************************************************************/
+NS_IMETHODIMP
+nsXPCComponents_Exception::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCComponents_Exception)
+    PUSH_IID(nsIXPCScriptable)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Exception::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    *retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Exception::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Exception::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "XPCComponents_Exception";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Exception::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Exception::GetFlags(uint32_t* aFlags)
+{
+    *aFlags = 0;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Exception::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsXPCComponents_Exception::nsXPCComponents_Exception()
+{
+}
+
+nsXPCComponents_Exception::~nsXPCComponents_Exception()
+{
+    // empty
+}
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_Exception)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_Exception)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_Exception)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_Exception)
+NS_IMPL_RELEASE(nsXPCComponents_Exception)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCComponents_Exception
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_Exception"
+#define                             XPC_MAP_WANT_CALL
+#define                             XPC_MAP_WANT_CONSTRUCT
+#define                             XPC_MAP_WANT_HASINSTANCE
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+
+NS_IMETHODIMP
+nsXPCComponents_Exception::Call(nsIXPConnectWrappedNative* wrapper, JSContext* cx, JSObject* objArg,
+                                const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Exception::Construct(nsIXPConnectWrappedNative* wrapper, JSContext* cx,
+                                     JSObject* objArg, const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+}
+
+struct MOZ_STACK_CLASS ExceptionArgParser
+{
+    ExceptionArgParser(JSContext* context,
+                       nsXPConnect* xpconnect)
+        : eMsg("exception")
+        , eResult(NS_ERROR_FAILURE)
+        , cx(context)
+        , xpc(xpconnect)
+    {}
+
+    // Public exception parameter values. During construction, these are
+    // initialized to the appropriate defaults.
+    const char*             eMsg;
+    nsresult                eResult;
+    nsCOMPtr<nsIStackFrame> eStack;
+    nsCOMPtr<nsISupports>   eData;
+
+    // Parse the constructor arguments into the above |eFoo| parameter values.
+    bool parse(const CallArgs& args) {
+        /*
+         * The Components.Exception takes a series of arguments, all of them
+         * optional:
+         *
+         * Argument 0: Exception message (defaults to 'exception').
+         * Argument 1: Result code (defaults to NS_ERROR_FAILURE) _or_ options
+         *             object (see below).
+         * Argument 2: Stack (defaults to the current stack, which we trigger
+         *                    by leaving this nullptr in the parser).
+         * Argument 3: Optional user data (defaults to nullptr).
+         *
+         * To dig our way out of this clunky API, we now support passing an
+         * options object as the second parameter (as opposed to a result code).
+         * If this is the case, all subsequent arguments are ignored, and the
+         * following properties are parsed out of the object (using the
+         * associated default if the property does not exist):
+         *
+         *   result:    Result code (see argument 1).
+         *   stack:     Call stack (see argument 2).
+         *   data:      User data (see argument 3).
+         */
+        if (args.length() > 0 && !parseMessage(args[0]))
+            return false;
+        if (args.length() > 1) {
+            if (args[1].isObject()) {
+                RootedObject obj(cx, &args[1].toObject());
+                return parseOptionsObject(obj);
+            }
+            if (!parseResult(args[1]))
+                return false;
+        }
+        if (args.length() > 2) {
+            if (!parseStack(args[2]))
+                return false;
+        }
+        if (args.length() > 3) {
+            if (!parseData(args[3]))
+                return false;
+        }
+        return true;
+    }
+
+  protected:
+
+    /*
+     * Parsing helpers.
+     */
+
+    bool parseMessage(HandleValue v) {
+        JSString* str = ToString(cx, v);
+        if (!str)
+           return false;
+        eMsg = messageBytes.encodeLatin1(cx, str);
+        return !!eMsg;
+    }
+
+    bool parseResult(HandleValue v) {
+        return JS::ToUint32(cx, v, (uint32_t*) &eResult);
+    }
+
+    bool parseStack(HandleValue v) {
+        if (!v.isObject()) {
+            // eStack has already been initialized to null, which is what we want
+            // for any non-object values (including null).
+            return true;
+        }
+
+        return NS_SUCCEEDED(xpc->WrapJS(cx, &v.toObject(),
+                                        NS_GET_IID(nsIStackFrame),
+                                        getter_AddRefs(eStack)));
+    }
+
+    bool parseData(HandleValue v) {
+        if (!v.isObject()) {
+            // eData has already been initialized to null, which is what we want
+            // for any non-object values (including null).
+            return true;
+        }
+
+        return NS_SUCCEEDED(xpc->WrapJS(cx, &v.toObject(),
+                                        NS_GET_IID(nsISupports),
+                                        getter_AddRefs(eData)));
+    }
+
+    bool parseOptionsObject(HandleObject obj) {
+        RootedValue v(cx);
+
+        if (!getOption(obj, "result", &v) ||
+            (!v.isUndefined() && !parseResult(v)))
+            return false;
+
+        if (!getOption(obj, "stack", &v) ||
+            (!v.isUndefined() && !parseStack(v)))
+            return false;
+
+        if (!getOption(obj, "data", &v) ||
+            (!v.isUndefined() && !parseData(v)))
+            return false;
+
+        return true;
+    }
+
+    bool getOption(HandleObject obj, const char* name, MutableHandleValue rv) {
+        // Look for the property.
+        bool found;
+        if (!JS_HasProperty(cx, obj, name, &found))
+            return false;
+
+        // If it wasn't found, indicate with undefined.
+        if (!found) {
+            rv.setUndefined();
+            return true;
+        }
+
+        // Get the property.
+        return JS_GetProperty(cx, obj, name, rv);
+    }
+
+    /*
+     * Internal data members.
+     */
+
+    // If there's a non-default exception string, hold onto the allocated bytes.
+    JSAutoByteString messageBytes;
+
+    // Various bits and pieces that are helpful to have around.
+    JSContext* cx;
+    nsXPConnect* xpc;
+};
+
+// static
+nsresult
+nsXPCComponents_Exception::CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
+                                           JSContext* cx, HandleObject obj,
+                                           const CallArgs& args, bool* _retval)
+{
+    nsXPConnect* xpc = nsXPConnect::XPConnect();
+
+    // Do the security check if necessary
+
+    if (NS_FAILED(nsXPConnect::SecurityManager()->CanCreateInstance(cx, Exception::GetCID()))) {
+        // the security manager vetoed. It should have set an exception.
+        *_retval = false;
+        return NS_OK;
+    }
+
+    // Parse the arguments to the Exception constructor.
+    ExceptionArgParser parser(cx, xpc);
+    if (!parser.parse(args))
+        return ThrowAndFail(NS_ERROR_XPC_BAD_CONVERT_JS, cx, _retval);
+
+    nsCOMPtr<nsIException> e = new Exception(nsCString(parser.eMsg),
+                                             parser.eResult,
+                                             EmptyCString(),
+                                             parser.eStack,
+                                             parser.eData);
+
+    RootedObject newObj(cx);
+    if (NS_FAILED(xpc->WrapNative(cx, obj, e, NS_GET_IID(nsIXPCException), newObj.address())) || !newObj) {
+        return ThrowAndFail(NS_ERROR_XPC_CANT_CREATE_WN, cx, _retval);
+    }
+
+    args.rval().setObject(*newObj);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Exception::HasInstance(nsIXPConnectWrappedNative* wrapper,
+                                       JSContext * cx, JSObject * obj,
+                                       HandleValue val, bool* bp,
+                                       bool* _retval)
+{
+    using namespace mozilla::dom;
+
+    if (bp) {
+        *bp = (val.isObject() &&
+               IS_INSTANCE_OF(Exception, &val.toObject())) ||
+              JSValIsInterfaceOfType(cx, val, NS_GET_IID(nsIException));
+    }
+    return NS_OK;
+}
+
+/***************************************************************************/
+// This class is for the thing returned by "new Component.Constructor".
+
+// XXXjband we use this CID for security check, but security system can't see
+// it since it has no registed factory. Security really kicks in when we try
+// to build a wrapper around an instance.
+
+// {B4A95150-E25A-11d3-8F61-0010A4E73D9A}
+#define NS_XPCCONSTRUCTOR_CID                                                 \
+{ 0xb4a95150, 0xe25a, 0x11d3,                                                 \
+    { 0x8f, 0x61, 0x0, 0x10, 0xa4, 0xe7, 0x3d, 0x9a } }
+
+class nsXPCConstructor :
+  public nsIXPCConstructor,
+  public nsIXPCScriptable,
+  public nsIClassInfo
+{
+public:
+    NS_DEFINE_STATIC_CID_ACCESSOR(NS_XPCCONSTRUCTOR_CID)
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCONSTRUCTOR
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSICLASSINFO
+
+public:
+    nsXPCConstructor() = delete;
+    nsXPCConstructor(nsIJSCID* aClassID,
+                     nsIJSIID* aInterfaceID,
+                     const char* aInitializer);
+
+private:
+    virtual ~nsXPCConstructor();
+    nsresult CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
+                             JSContext* cx, HandleObject obj,
+                             const CallArgs& args, bool* _retval);
+private:
+    RefPtr<nsIJSCID> mClassID;
+    RefPtr<nsIJSIID> mInterfaceID;
+    char*              mInitializer;
+};
+
+/***************************************************************************/
+NS_IMETHODIMP
+nsXPCConstructor::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCConstructor)
+    PUSH_IID(nsIXPCScriptable)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    *retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "XPCConstructor";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::GetFlags(uint32_t* aFlags)
+{
+    *aFlags = 0;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsXPCConstructor::nsXPCConstructor(nsIJSCID* aClassID,
+                                   nsIJSIID* aInterfaceID,
+                                   const char* aInitializer)
+    : mClassID(aClassID),
+      mInterfaceID(aInterfaceID)
+{
+    mInitializer = aInitializer ?
+        (char*) nsMemory::Clone(aInitializer, strlen(aInitializer)+1) :
+        nullptr;
+}
+
+nsXPCConstructor::~nsXPCConstructor()
+{
+    if (mInitializer)
+        free(mInitializer);
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::GetClassID(nsIJSCID * *aClassID)
+{
+    RefPtr<nsIJSCID> rval = mClassID;
+    rval.forget(aClassID);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::GetInterfaceID(nsIJSIID * *aInterfaceID)
+{
+    RefPtr<nsIJSIID> rval = mInterfaceID;
+    rval.forget(aInterfaceID);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::GetInitializer(char * *aInitializer)
+{
+    XPC_STRING_GETTER_BODY(aInitializer, mInitializer);
+}
+
+NS_INTERFACE_MAP_BEGIN(nsXPCConstructor)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCConstructor)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCConstructor)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCConstructor)
+NS_IMPL_RELEASE(nsXPCConstructor)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCConstructor
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCConstructor"
+#define                             XPC_MAP_WANT_CALL
+#define                             XPC_MAP_WANT_CONSTRUCT
+#define XPC_MAP_FLAGS               0
+#include "xpc_map_end.h" /* This will #undef the above */
+
+
+NS_IMETHODIMP
+nsXPCConstructor::Call(nsIXPConnectWrappedNative* wrapper, JSContext* cx, JSObject* objArg,
+                       const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+
+}
+
+NS_IMETHODIMP
+nsXPCConstructor::Construct(nsIXPConnectWrappedNative* wrapper, JSContext* cx, JSObject* objArg,
+                            const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+}
+
+// static
+nsresult
+nsXPCConstructor::CallOrConstruct(nsIXPConnectWrappedNative* wrapper,JSContext* cx,
+                                  HandleObject obj, const CallArgs& args, bool* _retval)
+{
+    nsXPConnect* xpc = nsXPConnect::XPConnect();
+
+    // security check not required because we are going to call through the
+    // code which is reflected into JS which will do that for us later.
+
+    RootedObject cidObj(cx);
+    RootedObject iidObj(cx);
+
+    if (NS_FAILED(xpc->WrapNative(cx, obj, mClassID, NS_GET_IID(nsIJSCID), cidObj.address())) || !cidObj ||
+        NS_FAILED(xpc->WrapNative(cx, obj, mInterfaceID, NS_GET_IID(nsIJSIID), iidObj.address())) || !iidObj) {
+        return ThrowAndFail(NS_ERROR_XPC_CANT_CREATE_WN, cx, _retval);
+    }
+
+    JS::Rooted<JS::Value> arg(cx, ObjectValue(*iidObj));
+    RootedValue rval(cx);
+    if (!JS_CallFunctionName(cx, cidObj, "createInstance", JS::HandleValueArray(arg), &rval) ||
+        rval.isPrimitive()) {
+        // createInstance will have thrown an exception
+        *_retval = false;
+        return NS_OK;
+    }
+
+    args.rval().set(rval);
+
+    // call initializer method if supplied
+    if (mInitializer) {
+        RootedObject newObj(cx, &rval.toObject());
+        // first check existence of function property for better error reporting
+        RootedValue fun(cx);
+        if (!JS_GetProperty(cx, newObj, mInitializer, &fun) ||
+            fun.isPrimitive()) {
+            return ThrowAndFail(NS_ERROR_XPC_BAD_INITIALIZER_NAME, cx, _retval);
+        }
+
+        RootedValue dummy(cx);
+        if (!JS_CallFunctionValue(cx, newObj, fun, args, &dummy)) {
+            // function should have thrown an exception
+            *_retval = false;
+            return NS_OK;
+        }
+    }
+
+    return NS_OK;
+}
+
+/*******************************************************/
+// JavaScript Constructor for nsIXPCConstructor objects (Components.Constructor)
+
+class nsXPCComponents_Constructor final :
+  public nsIXPCComponents_Constructor,
+  public nsIXPCScriptable,
+  public nsIClassInfo
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTS_CONSTRUCTOR
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSICLASSINFO
+
+public:
+    nsXPCComponents_Constructor();
+
+private:
+    virtual ~nsXPCComponents_Constructor();
+    static nsresult CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
+                                    JSContext* cx, HandleObject obj,
+                                    const CallArgs& args, bool* _retval);
+};
+
+/***************************************************************************/
+NS_IMETHODIMP
+nsXPCComponents_Constructor::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCComponents_Constructor)
+    PUSH_IID(nsIXPCScriptable)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Constructor::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    *retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Constructor::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Constructor::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "XPCComponents_Constructor";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Constructor::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Constructor::GetFlags(uint32_t* aFlags)
+{
+    *aFlags = 0;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Constructor::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+nsXPCComponents_Constructor::nsXPCComponents_Constructor()
+{
+}
+
+nsXPCComponents_Constructor::~nsXPCComponents_Constructor()
+{
+    // empty
+}
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_Constructor)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_Constructor)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_Constructor)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_Constructor)
+NS_IMPL_RELEASE(nsXPCComponents_Constructor)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCComponents_Constructor
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_Constructor"
+#define                             XPC_MAP_WANT_CALL
+#define                             XPC_MAP_WANT_CONSTRUCT
+#define                             XPC_MAP_WANT_HASINSTANCE
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+
+NS_IMETHODIMP
+nsXPCComponents_Constructor::Call(nsIXPConnectWrappedNative* wrapper, JSContext* cx,
+                                  JSObject* objArg, const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Constructor::Construct(nsIXPConnectWrappedNative* wrapper, JSContext* cx,
+                                       JSObject* objArg, const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    return CallOrConstruct(wrapper, cx, obj, args, _retval);
+}
+
+// static
+nsresult
+nsXPCComponents_Constructor::CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
+                                             JSContext* cx, HandleObject obj,
+                                             const CallArgs& args, bool* _retval)
+{
+    // make sure we have at least one arg
+
+    if (args.length() < 1)
+        return ThrowAndFail(NS_ERROR_XPC_NOT_ENOUGH_ARGS, cx, _retval);
+
+    // get the various other object pointers we need
+
+    nsXPConnect* xpc = nsXPConnect::XPConnect();
+    XPCWrappedNativeScope* scope = ObjectScope(obj);
+    nsCOMPtr<nsIXPCComponents> comp;
+
+    if (!xpc || !scope || !(comp = do_QueryInterface(scope->GetComponents())))
+        return ThrowAndFail(NS_ERROR_XPC_UNEXPECTED, cx, _retval);
+
+    // Do the security check if necessary
+
+    if (NS_FAILED(nsXPConnect::SecurityManager()->CanCreateInstance(cx, nsXPCConstructor::GetCID()))) {
+        // the security manager vetoed. It should have set an exception.
+        *_retval = false;
+        return NS_OK;
+    }
+
+    // initialization params for the Constructor object we will create
+    nsCOMPtr<nsIJSCID> cClassID;
+    nsCOMPtr<nsIJSIID> cInterfaceID;
+    const char*        cInitializer = nullptr;
+    JSAutoByteString  cInitializerBytes;
+
+    if (args.length() >= 3) {
+        // args[2] is an initializer function or property name
+        RootedString str(cx, ToString(cx, args[2]));
+        if (!str || !(cInitializer = cInitializerBytes.encodeLatin1(cx, str)))
+            return ThrowAndFail(NS_ERROR_XPC_BAD_CONVERT_JS, cx, _retval);
+    }
+
+    if (args.length() >= 2) {
+        // args[1] is an iid name string
+        // XXXjband support passing "Components.interfaces.foo"?
+
+        nsCOMPtr<nsIXPCComponents_Interfaces> ifaces;
+        RootedObject ifacesObj(cx);
+
+        // we do the lookup by asking the Components.interfaces object
+        // for the property with this name - i.e. we let its caching of these
+        // nsIJSIID objects work for us.
+
+        if (NS_FAILED(comp->GetInterfaces(getter_AddRefs(ifaces))) ||
+            NS_FAILED(xpc->WrapNative(cx, obj, ifaces,
+                                      NS_GET_IID(nsIXPCComponents_Interfaces),
+                                      ifacesObj.address())) || !ifacesObj) {
+            return ThrowAndFail(NS_ERROR_XPC_UNEXPECTED, cx, _retval);
+        }
+
+        RootedString str(cx, ToString(cx, args[1]));
+        RootedId id(cx);
+        if (!str || !JS_StringToId(cx, str, &id))
+            return ThrowAndFail(NS_ERROR_XPC_BAD_CONVERT_JS, cx, _retval);
+
+        RootedValue val(cx);
+        if (!JS_GetPropertyById(cx, ifacesObj, id, &val) || val.isPrimitive())
+            return ThrowAndFail(NS_ERROR_XPC_BAD_IID, cx, _retval);
+
+        nsCOMPtr<nsIXPConnectWrappedNative> wn;
+        if (NS_FAILED(xpc->GetWrappedNativeOfJSObject(cx, &val.toObject(),
+                                                      getter_AddRefs(wn))) || !wn ||
+            !(cInterfaceID = do_QueryWrappedNative(wn))) {
+            return ThrowAndFail(NS_ERROR_XPC_UNEXPECTED, cx, _retval);
+        }
+    } else {
+        nsCOMPtr<nsIInterfaceInfo> info;
+        xpc->GetInfoForIID(&NS_GET_IID(nsISupports), getter_AddRefs(info));
+
+        if (info) {
+            cInterfaceID = nsJSIID::NewID(info);
+        }
+        if (!cInterfaceID)
+            return ThrowAndFail(NS_ERROR_XPC_UNEXPECTED, cx, _retval);
+    }
+
+    // a new scope to avoid warnings about shadowed names
+    {
+        // argv[0] is a contractid name string
+        // XXXjband support passing "Components.classes.foo"?
+
+        // we do the lookup by asking the Components.classes object
+        // for the property with this name - i.e. we let its caching of these
+        // nsIJSCID objects work for us.
+
+        nsCOMPtr<nsIXPCComponents_Classes> classes;
+        RootedObject classesObj(cx);
+
+        if (NS_FAILED(comp->GetClasses(getter_AddRefs(classes))) ||
+            NS_FAILED(xpc->WrapNative(cx, obj, classes,
+                                      NS_GET_IID(nsIXPCComponents_Classes),
+                                      classesObj.address())) || !classesObj) {
+            return ThrowAndFail(NS_ERROR_XPC_UNEXPECTED, cx, _retval);
+        }
+
+        RootedString str(cx, ToString(cx, args[0]));
+        RootedId id(cx);
+        if (!str || !JS_StringToId(cx, str, &id))
+            return ThrowAndFail(NS_ERROR_XPC_BAD_CONVERT_JS, cx, _retval);
+
+        RootedValue val(cx);
+        if (!JS_GetPropertyById(cx, classesObj, id, &val) || val.isPrimitive())
+            return ThrowAndFail(NS_ERROR_XPC_BAD_CID, cx, _retval);
+
+        nsCOMPtr<nsIXPConnectWrappedNative> wn;
+        if (NS_FAILED(xpc->GetWrappedNativeOfJSObject(cx, val.toObjectOrNull(),
+                                                      getter_AddRefs(wn))) || !wn ||
+            !(cClassID = do_QueryWrappedNative(wn))) {
+            return ThrowAndFail(NS_ERROR_XPC_UNEXPECTED, cx, _retval);
+        }
+    }
+
+    nsCOMPtr<nsIXPCConstructor> ctor = new nsXPCConstructor(cClassID, cInterfaceID, cInitializer);
+    RootedObject newObj(cx);
+
+    if (NS_FAILED(xpc->WrapNative(cx, obj, ctor, NS_GET_IID(nsIXPCConstructor), newObj.address())) || !newObj) {
+        return ThrowAndFail(NS_ERROR_XPC_CANT_CREATE_WN, cx, _retval);
+    }
+
+    args.rval().setObject(*newObj);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Constructor::HasInstance(nsIXPConnectWrappedNative* wrapper,
+                                         JSContext * cx, JSObject * obj,
+                                         HandleValue val, bool* bp,
+                                         bool* _retval)
+{
+    if (bp)
+        *bp = JSValIsInterfaceOfType(cx, val, NS_GET_IID(nsIXPCConstructor));
+    return NS_OK;
+}
+
+class nsXPCComponents_Utils final :
+            public nsIXPCComponents_Utils,
+            public nsIXPCScriptable
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCSCRIPTABLE
+    NS_DECL_NSIXPCCOMPONENTS_UTILS
+
+public:
+    nsXPCComponents_Utils() { }
+
+private:
+    virtual ~nsXPCComponents_Utils() { }
+    nsCOMPtr<nsIXPCComponents_utils_Sandbox> mSandbox;
+};
+
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents_Utils)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCComponents_Utils)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCComponents_Utils)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsXPCComponents_Utils)
+NS_IMPL_RELEASE(nsXPCComponents_Utils)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsXPCComponents_Utils
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents_Utils"
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetSandbox(nsIXPCComponents_utils_Sandbox** aSandbox)
+{
+    NS_ENSURE_ARG_POINTER(aSandbox);
+    if (!mSandbox)
+        mSandbox = NewSandboxConstructor();
+
+    nsCOMPtr<nsIXPCComponents_utils_Sandbox> rval = mSandbox;
+    rval.forget(aSandbox);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::ReportError(HandleValue error, JSContext* cx)
+{
+    // This function shall never fail! Silently eat any failure conditions.
+
+    nsCOMPtr<nsIConsoleService> console(do_GetService(NS_CONSOLESERVICE_CONTRACTID));
+    if (!console)
+        return NS_OK;
+
+    nsGlobalWindow* globalWin = CurrentWindowOrNull(cx);
+    nsPIDOMWindowInner* win = globalWin ? globalWin->AsInner() : nullptr;
+    const uint64_t innerWindowID = win ? win->WindowID() : 0;
+
+    RootedObject errorObj(cx, error.isObject() ? &error.toObject() : nullptr);
+    JSErrorReport* err = errorObj ? JS_ErrorFromException(cx, errorObj) : nullptr;
+
+    nsCOMPtr<nsIScriptError> scripterr;
+
+    if (errorObj) {
+        JS::RootedObject stackVal(cx,
+          FindExceptionStackForConsoleReport(win, error));
+        if (stackVal) {
+            scripterr = new nsScriptErrorWithStack(stackVal);
+        }
+    }
+
+    nsString fileName;
+    int32_t lineNo = 0;
+
+    if (!scripterr) {
+        nsCOMPtr<nsIStackFrame> frame = dom::GetCurrentJSStack();
+        if (frame) {
+            frame->GetFilename(cx, fileName);
+            frame->GetLineNumber(cx, &lineNo);
+            JS::Rooted<JS::Value> stack(cx);
+            nsresult rv = frame->GetNativeSavedFrame(&stack);
+            if (NS_SUCCEEDED(rv) && stack.isObject()) {
+              JS::Rooted<JSObject*> stackObj(cx, &stack.toObject());
+              scripterr = new nsScriptErrorWithStack(stackObj);
+            }
+        }
+    }
+
+    if (!scripterr) {
+        scripterr = new nsScriptError();
+    }
+
+    if (err) {
+        // It's a proper JS Error
+        nsAutoString fileUni;
+        CopyUTF8toUTF16(err->filename, fileUni);
+
+        uint32_t column = err->tokenOffset();
+
+        const char16_t* linebuf = err->linebuf();
+
+        nsresult rv = scripterr->InitWithWindowID(
+                err->message() ? NS_ConvertUTF8toUTF16(err->message().c_str())
+                : EmptyString(),
+                fileUni,
+                linebuf ? nsDependentString(linebuf, err->linebufLength()) : EmptyString(),
+                err->lineno,
+                column, err->flags, "XPConnect JavaScript", innerWindowID);
+        NS_ENSURE_SUCCESS(rv, NS_OK);
+
+        console->LogMessage(scripterr);
+        return NS_OK;
+    }
+
+    // It's not a JS Error object, so we synthesize as best we're able.
+    RootedString msgstr(cx, ToString(cx, error));
+    if (!msgstr)
+        return NS_OK;
+
+    nsAutoJSString msg;
+    if (!msg.init(cx, msgstr))
+        return NS_OK;
+
+    nsresult rv = scripterr->InitWithWindowID(
+            msg, fileName, EmptyString(), lineNo, 0, 0,
+            "XPConnect JavaScript", innerWindowID);
+    NS_ENSURE_SUCCESS(rv, NS_OK);
+
+    console->LogMessage(scripterr);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::EvalInSandbox(const nsAString& source,
+                                     HandleValue sandboxVal,
+                                     HandleValue version,
+                                     const nsACString& filenameArg,
+                                     int32_t lineNumber,
+                                     JSContext* cx,
+                                     uint8_t optionalArgc,
+                                     MutableHandleValue retval)
+{
+    RootedObject sandbox(cx);
+    if (!JS_ValueToObject(cx, sandboxVal, &sandbox) || !sandbox)
+        return NS_ERROR_INVALID_ARG;
+
+    // Optional third argument: JS version, as a string.
+    JSVersion jsVersion = JSVERSION_DEFAULT;
+    if (optionalArgc >= 1) {
+        JSString* jsVersionStr = ToString(cx, version);
+        if (!jsVersionStr)
+            return NS_ERROR_INVALID_ARG;
+
+        JSAutoByteString bytes(cx, jsVersionStr);
+        if (!bytes)
+            return NS_ERROR_INVALID_ARG;
+
+        jsVersion = JS_StringToVersion(bytes.ptr());
+        // Explicitly check for "latest", which we support for sandboxes but
+        // isn't in the set of web-exposed version strings.
+        if (jsVersion == JSVERSION_UNKNOWN &&
+            !strcmp(bytes.ptr(), "latest"))
+        {
+            jsVersion = JSVERSION_LATEST;
+        }
+        if (jsVersion == JSVERSION_UNKNOWN)
+            return NS_ERROR_INVALID_ARG;
+    }
+
+    // Optional fourth and fifth arguments: filename and line number.
+    int32_t lineNo = (optionalArgc >= 3) ? lineNumber : 1;
+    nsCString filename;
+    if (!filenameArg.IsVoid()) {
+        filename.Assign(filenameArg);
+    } else {
+        // Get the current source info from xpc.
+        nsresult rv;
+        nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID(), &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        nsCOMPtr<nsIStackFrame> frame;
+        xpc->GetCurrentJSStack(getter_AddRefs(frame));
+        if (frame) {
+            nsString frameFile;
+            frame->GetFilename(cx, frameFile);
+            CopyUTF16toUTF8(frameFile, filename);
+            frame->GetLineNumber(cx, &lineNo);
+        }
+    }
+
+    return xpc::EvalInSandbox(cx, sandbox, source, filename, lineNo,
+                              jsVersion, retval);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetSandboxAddonId(HandleValue sandboxVal,
+                                         JSContext* cx, MutableHandleValue rval)
+{
+    if (!sandboxVal.isObject())
+        return NS_ERROR_INVALID_ARG;
+
+    RootedObject sandbox(cx, &sandboxVal.toObject());
+    sandbox = js::CheckedUnwrap(sandbox);
+    if (!sandbox || !xpc::IsSandbox(sandbox))
+        return NS_ERROR_INVALID_ARG;
+
+    return xpc::GetSandboxAddonId(cx, sandbox, rval);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetSandboxMetadata(HandleValue sandboxVal,
+                                          JSContext* cx, MutableHandleValue rval)
+{
+    if (!sandboxVal.isObject())
+        return NS_ERROR_INVALID_ARG;
+
+    RootedObject sandbox(cx, &sandboxVal.toObject());
+    sandbox = js::CheckedUnwrap(sandbox);
+    if (!sandbox || !xpc::IsSandbox(sandbox))
+        return NS_ERROR_INVALID_ARG;
+
+    return xpc::GetSandboxMetadata(cx, sandbox, rval);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::SetSandboxMetadata(HandleValue sandboxVal,
+                                          HandleValue metadataVal,
+                                          JSContext* cx)
+{
+    if (!sandboxVal.isObject())
+        return NS_ERROR_INVALID_ARG;
+
+    RootedObject sandbox(cx, &sandboxVal.toObject());
+    sandbox = js::CheckedUnwrap(sandbox);
+    if (!sandbox || !xpc::IsSandbox(sandbox))
+        return NS_ERROR_INVALID_ARG;
+
+    nsresult rv = xpc::SetSandboxMetadata(cx, sandbox, metadataVal);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::Import(const nsACString& registryLocation,
+                              HandleValue targetObj,
+                              JSContext* cx,
+                              uint8_t optionalArgc,
+                              MutableHandleValue retval)
+{
+    nsCOMPtr<xpcIJSModuleLoader> moduleloader =
+        do_GetService(MOZJSCOMPONENTLOADER_CONTRACTID);
+    if (!moduleloader)
+        return NS_ERROR_FAILURE;
+    return moduleloader->Import(registryLocation, targetObj, cx, optionalArgc, retval);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::IsModuleLoaded(const nsACString& registryLocation, bool* retval)
+{
+    nsCOMPtr<xpcIJSModuleLoader> moduleloader =
+        do_GetService(MOZJSCOMPONENTLOADER_CONTRACTID);
+    if (!moduleloader)
+        return NS_ERROR_FAILURE;
+    return moduleloader->IsModuleLoaded(registryLocation, retval);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::Unload(const nsACString & registryLocation)
+{
+    nsCOMPtr<xpcIJSModuleLoader> moduleloader =
+        do_GetService(MOZJSCOMPONENTLOADER_CONTRACTID);
+    if (!moduleloader)
+        return NS_ERROR_FAILURE;
+    return moduleloader->Unload(registryLocation);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::ImportGlobalProperties(HandleValue aPropertyList,
+                                              JSContext* cx)
+{
+    RootedObject global(cx, CurrentGlobalOrNull(cx));
+    MOZ_ASSERT(global);
+
+    // Don't allow doing this if the global is a Window
+    nsGlobalWindow* win;
+    if (NS_SUCCEEDED(UNWRAP_OBJECT(Window, &global, win))) {
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    GlobalProperties options;
+    NS_ENSURE_TRUE(aPropertyList.isObject(), NS_ERROR_INVALID_ARG);
+
+    RootedObject propertyList(cx, &aPropertyList.toObject());
+    bool isArray;
+    if (NS_WARN_IF(!JS_IsArrayObject(cx, propertyList, &isArray))) {
+        return NS_ERROR_FAILURE;
+    }
+    if (NS_WARN_IF(!isArray)) {
+        return NS_ERROR_INVALID_ARG;
+    }
+
+    if (!options.Parse(cx, propertyList) ||
+        !options.DefineInXPCComponents(cx, global))
+    {
+        return NS_ERROR_FAILURE;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetWeakReference(HandleValue object, JSContext* cx,
+                                        xpcIJSWeakReference** _retval)
+{
+    RefPtr<xpcJSWeakReference> ref = new xpcJSWeakReference();
+    nsresult rv = ref->Init(cx, object);
+    NS_ENSURE_SUCCESS(rv, rv);
+    ref.forget(_retval);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::ForceGC()
+{
+    JSContext* cx = nsXPConnect::GetContextInstance()->Context();
+    PrepareForFullGC(cx);
+    GCForReason(cx, GC_NORMAL, gcreason::COMPONENT_UTILS);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::ForceCC(nsICycleCollectorListener* listener)
+{
+    nsJSContext::CycleCollectNow(listener);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::FinishCC()
+{
+    nsCycleCollector_finishAnyCurrentCollection();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::CcSlice(int64_t budget)
+{
+    nsJSContext::RunCycleCollectorWorkSlice(budget);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetMaxCCSliceTimeSinceClear(int32_t* out)
+{
+    *out = nsJSContext::GetMaxCCSliceTimeSinceClear();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::ClearMaxCCTime()
+{
+    nsJSContext::ClearMaxCCSliceTime();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::ForceShrinkingGC()
+{
+    JSContext* cx = dom::danger::GetJSContext();
+    PrepareForFullGC(cx);
+    GCForReason(cx, GC_SHRINK, gcreason::COMPONENT_UTILS);
+    return NS_OK;
+}
+
+class PreciseGCRunnable : public Runnable
+{
+  public:
+    PreciseGCRunnable(ScheduledGCCallback* aCallback, bool aShrinking)
+    : mCallback(aCallback), mShrinking(aShrinking) {}
+
+    NS_IMETHOD Run() override
+    {
+        JSContext* cx = dom::danger::GetJSContext();
+        if (JS_IsRunning(cx))
+            return NS_DispatchToMainThread(this);
+
+        nsJSContext::GarbageCollectNow(gcreason::COMPONENT_UTILS,
+                                       nsJSContext::NonIncrementalGC,
+                                       mShrinking ?
+                                         nsJSContext::ShrinkingGC :
+                                         nsJSContext::NonShrinkingGC);
+
+        mCallback->Callback();
+        return NS_OK;
+    }
+
+  private:
+    RefPtr<ScheduledGCCallback> mCallback;
+    bool mShrinking;
+};
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::SchedulePreciseGC(ScheduledGCCallback* aCallback)
+{
+    RefPtr<PreciseGCRunnable> event = new PreciseGCRunnable(aCallback, false);
+    return NS_DispatchToMainThread(event);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::SchedulePreciseShrinkingGC(ScheduledGCCallback* aCallback)
+{
+    RefPtr<PreciseGCRunnable> event = new PreciseGCRunnable(aCallback, true);
+    return NS_DispatchToMainThread(event);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::UnlinkGhostWindows()
+{
+#ifdef DEBUG
+    nsWindowMemoryReporter::UnlinkGhostWindows();
+    return NS_OK;
+#else
+    return NS_ERROR_NOT_IMPLEMENTED;
+#endif
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetJSTestingFunctions(JSContext* cx,
+                                             MutableHandleValue retval)
+{
+    JSObject* obj = js::GetTestingFunctions(cx);
+    if (!obj)
+        return NS_ERROR_XPC_JAVASCRIPT_ERROR;
+    retval.setObject(*obj);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::CallFunctionWithAsyncStack(HandleValue function,
+                                                  nsIStackFrame* stack,
+                                                  const nsAString& asyncCause,
+                                                  JSContext* cx,
+                                                  MutableHandleValue retval)
+{
+    nsresult rv;
+
+    if (!stack || asyncCause.IsEmpty()) {
+        return NS_ERROR_INVALID_ARG;
+    }
+
+    JS::Rooted<JS::Value> asyncStack(cx);
+    rv = stack->GetNativeSavedFrame(&asyncStack);
+    if (NS_FAILED(rv))
+        return rv;
+    if (!asyncStack.isObject()) {
+        JS_ReportErrorASCII(cx, "Must use a native JavaScript stack frame");
+        return NS_ERROR_INVALID_ARG;
+    }
+
+    JS::Rooted<JSObject*> asyncStackObj(cx, &asyncStack.toObject());
+
+    NS_ConvertUTF16toUTF8 utf8Cause(asyncCause);
+    JS::AutoSetAsyncStackForNewCalls sas(cx, asyncStackObj, utf8Cause.get(),
+                                         JS::AutoSetAsyncStackForNewCalls::AsyncCallKind::EXPLICIT);
+
+    if (!JS_CallFunctionValue(cx, nullptr, function,
+                              JS::HandleValueArray::empty(), retval))
+    {
+        return NS_ERROR_XPC_JAVASCRIPT_ERROR;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetGlobalForObject(HandleValue object,
+                                          JSContext* cx,
+                                          MutableHandleValue retval)
+{
+    // First argument must be an object.
+    if (object.isPrimitive())
+        return NS_ERROR_XPC_BAD_CONVERT_JS;
+
+    // Wrappers are parented to their the global in their home compartment. But
+    // when getting the global for a cross-compartment wrapper, we really want
+    // a wrapper for the foreign global. So we need to unwrap before getting the
+    // parent, enter the compartment for the duration of the call, and wrap the
+    // result.
+    Rooted<JSObject*> obj(cx, &object.toObject());
+    obj = js::UncheckedUnwrap(obj);
+    {
+        JSAutoCompartment ac(cx, obj);
+        obj = JS_GetGlobalForObject(cx, obj);
+    }
+
+    if (!JS_WrapObject(cx, &obj))
+        return NS_ERROR_FAILURE;
+
+    // Get the WindowProxy if necessary.
+    obj = js::ToWindowProxyIfWindow(obj);
+
+    retval.setObject(*obj);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::IsProxy(HandleValue vobj, JSContext* cx, bool* rval)
+{
+    if (!vobj.isObject()) {
+        *rval = false;
+        return NS_OK;
+    }
+
+    RootedObject obj(cx, &vobj.toObject());
+    obj = js::CheckedUnwrap(obj, /* stopAtWindowProxy = */ false);
+    NS_ENSURE_TRUE(obj, NS_ERROR_FAILURE);
+
+    *rval = js::IsScriptedProxy(obj);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::ExportFunction(HandleValue vfunction, HandleValue vscope,
+                                      HandleValue voptions, JSContext* cx,
+                                      MutableHandleValue rval)
+{
+    if (!xpc::ExportFunction(cx, vfunction, vscope, voptions, rval))
+        return NS_ERROR_FAILURE;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::CreateObjectIn(HandleValue vobj, HandleValue voptions,
+                                      JSContext* cx, MutableHandleValue rval)
+{
+    RootedObject optionsObject(cx, voptions.isObject() ? &voptions.toObject()
+                                                       : nullptr);
+    CreateObjectInOptions options(cx, optionsObject);
+    if (voptions.isObject() &&
+        !options.Parse())
+    {
+        return NS_ERROR_FAILURE;
+    }
+
+    if (!xpc::CreateObjectIn(cx, vobj, options, rval))
+        return NS_ERROR_FAILURE;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::MakeObjectPropsNormal(HandleValue vobj, JSContext* cx)
+{
+    if (!cx)
+        return NS_ERROR_FAILURE;
+
+    // first argument must be an object
+    if (vobj.isPrimitive())
+        return NS_ERROR_XPC_BAD_CONVERT_JS;
+
+    RootedObject obj(cx, js::UncheckedUnwrap(&vobj.toObject()));
+    JSAutoCompartment ac(cx, obj);
+    Rooted<IdVector> ida(cx, IdVector(cx));
+    if (!JS_Enumerate(cx, obj, &ida))
+        return NS_ERROR_FAILURE;
+
+    RootedId id(cx);
+    RootedValue v(cx);
+    for (size_t i = 0; i < ida.length(); ++i) {
+        id = ida[i];
+
+        if (!JS_GetPropertyById(cx, obj, id, &v))
+            return NS_ERROR_FAILURE;
+
+        if (v.isPrimitive())
+            continue;
+
+        RootedObject propobj(cx, &v.toObject());
+        // TODO Deal with non-functions.
+        if (!js::IsWrapper(propobj) || !JS::IsCallable(propobj))
+            continue;
+
+        FunctionForwarderOptions forwarderOptions;
+        if (!NewFunctionForwarder(cx, id, propobj, forwarderOptions, &v) ||
+            !JS_SetPropertyById(cx, obj, id, v))
+            return NS_ERROR_FAILURE;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::IsDeadWrapper(HandleValue obj, bool* out)
+{
+    *out = false;
+    if (obj.isPrimitive())
+        return NS_ERROR_INVALID_ARG;
+
+    // Make sure to unwrap first. Once a proxy is nuked, it ceases to be a
+    // wrapper, meaning that, if passed to another compartment, we'll generate
+    // a CCW for it. Make sure that IsDeadWrapper sees through the confusion.
+    *out = JS_IsDeadWrapper(js::CheckedUnwrap(&obj.toObject()));
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::IsCrossProcessWrapper(HandleValue obj, bool* out)
+{
+    *out = false;
+    if (obj.isPrimitive())
+        return NS_ERROR_INVALID_ARG;
+
+    *out = jsipc::IsWrappedCPOW(&obj.toObject());
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetCrossProcessWrapperTag(HandleValue obj, nsACString& out)
+{
+    if (obj.isPrimitive() || !jsipc::IsWrappedCPOW(&obj.toObject()))
+        return NS_ERROR_INVALID_ARG;
+
+    jsipc::GetWrappedCPOWTag(&obj.toObject(), out);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::PermitCPOWsInScope(HandleValue obj)
+{
+    if (!obj.isObject())
+        return NS_ERROR_INVALID_ARG;
+
+    JSObject* scopeObj = js::UncheckedUnwrap(&obj.toObject());
+    CompartmentPrivate::Get(scopeObj)->allowCPOWs = true;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::RecomputeWrappers(HandleValue vobj, JSContext* cx)
+{
+    // Determine the compartment of the given object, if any.
+    JSCompartment* c = vobj.isObject()
+                       ? js::GetObjectCompartment(js::UncheckedUnwrap(&vobj.toObject()))
+                       : nullptr;
+
+    // If no compartment was given, recompute all.
+    if (!c)
+        js::RecomputeWrappers(cx, js::AllCompartments(), js::AllCompartments());
+    // Otherwise, recompute wrappers for the given compartment.
+    else
+        js::RecomputeWrappers(cx, js::SingleCompartment(c), js::AllCompartments()) &&
+        js::RecomputeWrappers(cx, js::AllCompartments(), js::SingleCompartment(c));
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::SetWantXrays(HandleValue vscope, JSContext* cx)
+{
+    if (!vscope.isObject())
+        return NS_ERROR_INVALID_ARG;
+    JSObject* scopeObj = js::UncheckedUnwrap(&vscope.toObject());
+    JSCompartment* compartment = js::GetObjectCompartment(scopeObj);
+    CompartmentPrivate::Get(scopeObj)->wantXrays = true;
+    bool ok = js::RecomputeWrappers(cx, js::SingleCompartment(compartment),
+                                    js::AllCompartments());
+    NS_ENSURE_TRUE(ok, NS_ERROR_FAILURE);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::ForcePermissiveCOWs(JSContext* cx)
+{
+    CrashIfNotInAutomation();
+    CompartmentPrivate::Get(CurrentGlobalOrNull(cx))->forcePermissiveCOWs = true;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::ForcePrivilegedComponentsForScope(HandleValue vscope,
+                                                         JSContext* cx)
+{
+    if (!vscope.isObject())
+        return NS_ERROR_INVALID_ARG;
+    CrashIfNotInAutomation();
+    JSObject* scopeObj = js::UncheckedUnwrap(&vscope.toObject());
+    XPCWrappedNativeScope* scope = ObjectScope(scopeObj);
+    scope->ForcePrivilegedComponents();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetComponentsForScope(HandleValue vscope, JSContext* cx,
+                                             MutableHandleValue rval)
+{
+    if (!vscope.isObject())
+        return NS_ERROR_INVALID_ARG;
+    JSObject* scopeObj = js::UncheckedUnwrap(&vscope.toObject());
+    XPCWrappedNativeScope* scope = ObjectScope(scopeObj);
+    RootedObject components(cx);
+    if (!scope->GetComponentsJSObject(&components))
+        return NS_ERROR_FAILURE;
+    if (!JS_WrapObject(cx, &components))
+        return NS_ERROR_FAILURE;
+    rval.setObject(*components);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::Dispatch(HandleValue runnableArg, HandleValue scope,
+                                JSContext* cx)
+{
+    RootedValue runnable(cx, runnableArg);
+    // Enter the given compartment, if any, and rewrap runnable.
+    Maybe<JSAutoCompartment> ac;
+    if (scope.isObject()) {
+        JSObject* scopeObj = js::UncheckedUnwrap(&scope.toObject());
+        if (!scopeObj)
+            return NS_ERROR_FAILURE;
+        ac.emplace(cx, scopeObj);
+        if (!JS_WrapValue(cx, &runnable))
+            return NS_ERROR_FAILURE;
+    }
+
+    // Get an XPCWrappedJS for |runnable|.
+    if (!runnable.isObject())
+        return NS_ERROR_INVALID_ARG;
+
+    nsCOMPtr<nsIRunnable> run;
+    nsresult rv = nsXPConnect::XPConnect()->WrapJS(cx, &runnable.toObject(),
+                                                   NS_GET_IID(nsIRunnable),
+                                                   getter_AddRefs(run));
+    NS_ENSURE_SUCCESS(rv, rv);
+    MOZ_ASSERT(run);
+
+    // Dispatch.
+    return NS_DispatchToMainThread(run);
+}
+
+#define GENERATE_JSCONTEXTOPTION_GETTER_SETTER(_attr, _getter, _setter) \
+    NS_IMETHODIMP                                                       \
+    nsXPCComponents_Utils::Get## _attr(JSContext* cx, bool* aValue)     \
+    {                                                                   \
+        *aValue = ContextOptionsRef(cx)._getter();                      \
+        return NS_OK;                                                   \
+    }                                                                   \
+    NS_IMETHODIMP                                                       \
+    nsXPCComponents_Utils::Set## _attr(JSContext* cx, bool aValue)      \
+    {                                                                   \
+        ContextOptionsRef(cx)._setter(aValue);                          \
+        return NS_OK;                                                   \
+    }
+
+GENERATE_JSCONTEXTOPTION_GETTER_SETTER(Strict, extraWarnings, setExtraWarnings)
+GENERATE_JSCONTEXTOPTION_GETTER_SETTER(Werror, werror, setWerror)
+GENERATE_JSCONTEXTOPTION_GETTER_SETTER(Strict_mode, strictMode, setStrictMode)
+GENERATE_JSCONTEXTOPTION_GETTER_SETTER(Ion, ion, setIon)
+
+#undef GENERATE_JSCONTEXTOPTION_GETTER_SETTER
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::SetGCZeal(int32_t aValue, JSContext* cx)
+{
+#ifdef JS_GC_ZEAL
+    JS_SetGCZeal(cx, uint8_t(aValue), JS_DEFAULT_ZEAL_FREQ);
+#endif
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::NukeSandbox(HandleValue obj, JSContext* cx)
+{
+    PROFILER_LABEL_FUNC(js::ProfileEntry::Category::JS);
+    NS_ENSURE_TRUE(obj.isObject(), NS_ERROR_INVALID_ARG);
+    JSObject* wrapper = &obj.toObject();
+    NS_ENSURE_TRUE(IsWrapper(wrapper), NS_ERROR_INVALID_ARG);
+    JSObject* sb = UncheckedUnwrap(wrapper);
+    NS_ENSURE_TRUE(IsSandbox(sb), NS_ERROR_INVALID_ARG);
+    NukeCrossCompartmentWrappers(cx, AllCompartments(),
+                                 SingleCompartment(GetObjectCompartment(sb)),
+                                 NukeWindowReferences);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::BlockScriptForGlobal(HandleValue globalArg,
+                                            JSContext* cx)
+{
+    NS_ENSURE_TRUE(globalArg.isObject(), NS_ERROR_INVALID_ARG);
+    RootedObject global(cx, UncheckedUnwrap(&globalArg.toObject(),
+                                            /* stopAtWindowProxy = */ false));
+    NS_ENSURE_TRUE(JS_IsGlobalObject(global), NS_ERROR_INVALID_ARG);
+    if (nsContentUtils::IsSystemPrincipal(xpc::GetObjectPrincipal(global))) {
+        JS_ReportErrorASCII(cx, "Script may not be disabled for system globals");
+        return NS_ERROR_FAILURE;
+    }
+    Scriptability::Get(global).Block();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::UnblockScriptForGlobal(HandleValue globalArg,
+                                              JSContext* cx)
+{
+    NS_ENSURE_TRUE(globalArg.isObject(), NS_ERROR_INVALID_ARG);
+    RootedObject global(cx, UncheckedUnwrap(&globalArg.toObject(),
+                                            /* stopAtWindowProxy = */ false));
+    NS_ENSURE_TRUE(JS_IsGlobalObject(global), NS_ERROR_INVALID_ARG);
+    if (nsContentUtils::IsSystemPrincipal(xpc::GetObjectPrincipal(global))) {
+        JS_ReportErrorASCII(cx, "Script may not be disabled for system globals");
+        return NS_ERROR_FAILURE;
+    }
+    Scriptability::Get(global).Unblock();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::IsXrayWrapper(HandleValue obj, bool* aRetval)
+{
+    *aRetval =
+        obj.isObject() && xpc::WrapperFactory::IsXrayWrapper(&obj.toObject());
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::WaiveXrays(HandleValue aVal, JSContext* aCx, MutableHandleValue aRetval)
+{
+    RootedValue value(aCx, aVal);
+    if (!xpc::WrapperFactory::WaiveXrayAndWrap(aCx, &value))
+        return NS_ERROR_FAILURE;
+    aRetval.set(value);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::UnwaiveXrays(HandleValue aVal, JSContext* aCx, MutableHandleValue aRetval)
+{
+    if (!aVal.isObject()) {
+        aRetval.set(aVal);
+        return NS_OK;
+    }
+
+    RootedObject obj(aCx, js::UncheckedUnwrap(&aVal.toObject()));
+    if (!JS_WrapObject(aCx, &obj))
+        return NS_ERROR_FAILURE;
+    aRetval.setObject(*obj);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetClassName(HandleValue aObj, bool aUnwrap, JSContext* aCx, char** aRv)
+{
+    if (!aObj.isObject())
+        return NS_ERROR_INVALID_ARG;
+    RootedObject obj(aCx, &aObj.toObject());
+    if (aUnwrap)
+        obj = js::UncheckedUnwrap(obj, /* stopAtWindowProxy = */ false);
+    *aRv = NS_strdup(js::GetObjectClass(obj)->name);
+    NS_ENSURE_TRUE(*aRv, NS_ERROR_OUT_OF_MEMORY);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetDOMClassInfo(const nsAString& aClassName,
+                                       nsIClassInfo** aClassInfo)
+{
+    *aClassInfo = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetIncumbentGlobal(HandleValue aCallback,
+                                          JSContext* aCx, MutableHandleValue aOut)
+{
+    nsCOMPtr<nsIGlobalObject> global = mozilla::dom::GetIncumbentGlobal();
+    RootedValue globalVal(aCx);
+
+    if (!global) {
+        globalVal = NullValue();
+    } else {
+        // Note: We rely on the wrap call for outerization.
+        globalVal = ObjectValue(*global->GetGlobalJSObject());
+        if (!JS_WrapValue(aCx, &globalVal))
+            return NS_ERROR_FAILURE;
+    }
+
+    // Invoke the callback, if passed.
+    if (aCallback.isObject()) {
+        RootedValue ignored(aCx);
+        if (!JS_CallFunctionValue(aCx, nullptr, aCallback, JS::HandleValueArray(globalVal), &ignored))
+            return NS_ERROR_FAILURE;
+    }
+
+    aOut.set(globalVal);
+    return NS_OK;
+}
+
+/*
+ * Below is a bunch of awkward junk to allow JS test code to trigger the
+ * creation of an XPCWrappedJS, such that it ends up in the map. We need to
+ * hand the caller some sort of reference to hold onto (to prevent the
+ * refcount from dropping to zero as soon as the function returns), but trying
+ * to return a bonafide XPCWrappedJS to script causes all sorts of trouble. So
+ * we create a benign holder class instead, which acts as an opaque reference
+ * that script can use to keep the XPCWrappedJS alive and in the map.
+ */
+
+class WrappedJSHolder : public nsISupports
+{
+    NS_DECL_ISUPPORTS
+    WrappedJSHolder() {}
+
+    RefPtr<nsXPCWrappedJS> mWrappedJS;
+
+private:
+    virtual ~WrappedJSHolder() {}
+};
+NS_IMPL_ISUPPORTS0(WrappedJSHolder);
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GenerateXPCWrappedJS(HandleValue aObj, HandleValue aScope,
+                                            JSContext* aCx, nsISupports** aOut)
+{
+    if (!aObj.isObject())
+        return NS_ERROR_INVALID_ARG;
+    RootedObject obj(aCx, &aObj.toObject());
+    RootedObject scope(aCx, aScope.isObject() ? js::UncheckedUnwrap(&aScope.toObject())
+                                              : CurrentGlobalOrNull(aCx));
+    JSAutoCompartment ac(aCx, scope);
+    if (!JS_WrapObject(aCx, &obj))
+        return NS_ERROR_FAILURE;
+
+    RefPtr<WrappedJSHolder> holder = new WrappedJSHolder();
+    nsresult rv = nsXPCWrappedJS::GetNewOrUsed(obj, NS_GET_IID(nsISupports),
+                                               getter_AddRefs(holder->mWrappedJS));
+    holder.forget(aOut);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetWatchdogTimestamp(const nsAString& aCategory, PRTime* aOut)
+{
+    WatchdogTimestampCategory category;
+    if (aCategory.EqualsLiteral("ContextStateChange"))
+        category = TimestampContextStateChange;
+    else if (aCategory.EqualsLiteral("WatchdogWakeup"))
+        category = TimestampWatchdogWakeup;
+    else if (aCategory.EqualsLiteral("WatchdogHibernateStart"))
+        category = TimestampWatchdogHibernateStart;
+    else if (aCategory.EqualsLiteral("WatchdogHibernateStop"))
+        category = TimestampWatchdogHibernateStop;
+    else
+        return NS_ERROR_INVALID_ARG;
+    *aOut = XPCJSContext::Get()->GetWatchdogTimestamp(category);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetJSEngineTelemetryValue(JSContext* cx, MutableHandleValue rval)
+{
+    RootedObject obj(cx, JS_NewPlainObject(cx));
+    if (!obj)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    unsigned attrs = JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT;
+
+    size_t i = JS_SetProtoCalled(cx);
+    RootedValue v(cx, DoubleValue(i));
+    if (!JS_DefineProperty(cx, obj, "setProto", v, attrs))
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    i = JS_GetCustomIteratorCount(cx);
+    v.setDouble(i);
+    if (!JS_DefineProperty(cx, obj, "customIter", v, attrs))
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    rval.setObject(*obj);
+    return NS_OK;
+}
+
+bool
+xpc::CloneInto(JSContext* aCx, HandleValue aValue, HandleValue aScope,
+               HandleValue aOptions, MutableHandleValue aCloned)
+{
+    if (!aScope.isObject())
+        return false;
+
+    RootedObject scope(aCx, &aScope.toObject());
+    scope = js::CheckedUnwrap(scope);
+    if(!scope) {
+        JS_ReportErrorASCII(aCx, "Permission denied to clone object into scope");
+        return false;
+    }
+
+    if (!aOptions.isUndefined() && !aOptions.isObject()) {
+        JS_ReportErrorASCII(aCx, "Invalid argument");
+        return false;
+    }
+
+    RootedObject optionsObject(aCx, aOptions.isObject() ? &aOptions.toObject()
+                                                        : nullptr);
+    StackScopedCloneOptions options(aCx, optionsObject);
+    if (aOptions.isObject() && !options.Parse())
+        return false;
+
+    {
+        JSAutoCompartment ac(aCx, scope);
+        aCloned.set(aValue);
+        if (!StackScopedClone(aCx, options, aCloned))
+            return false;
+    }
+
+    return JS_WrapValue(aCx, aCloned);
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::CloneInto(HandleValue aValue, HandleValue aScope,
+                                 HandleValue aOptions, JSContext* aCx,
+                                 MutableHandleValue aCloned)
+{
+    return xpc::CloneInto(aCx, aValue, aScope, aOptions, aCloned) ?
+           NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetWebIDLCallerPrincipal(nsIPrincipal** aResult)
+{
+    // This API may only be when the Entry Settings Object corresponds to a
+    // JS-implemented WebIDL call. In all other cases, the value will be null,
+    // and we throw.
+    nsCOMPtr<nsIPrincipal> callerPrin = mozilla::dom::GetWebIDLCallerPrincipal();
+    if (!callerPrin)
+        return NS_ERROR_NOT_AVAILABLE;
+    callerPrin.forget(aResult);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetObjectPrincipal(HandleValue val, JSContext* cx,
+                                          nsIPrincipal** result)
+{
+    if (!val.isObject())
+        return NS_ERROR_INVALID_ARG;
+    RootedObject obj(cx, &val.toObject());
+    obj = js::CheckedUnwrap(obj);
+    MOZ_ASSERT(obj);
+
+    nsCOMPtr<nsIPrincipal> prin = nsContentUtils::ObjectPrincipal(obj);
+    prin.forget(result);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::GetCompartmentLocation(HandleValue val,
+                                              JSContext* cx,
+                                              nsACString& result)
+{
+    if (!val.isObject())
+        return NS_ERROR_INVALID_ARG;
+    RootedObject obj(cx, &val.toObject());
+    obj = js::CheckedUnwrap(obj);
+    MOZ_ASSERT(obj);
+
+    result = xpc::CompartmentPrivate::Get(obj)->GetLocation();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::SetAddonInterposition(const nsACString& addonIdStr,
+                                             nsIAddonInterposition* interposition,
+                                             JSContext* cx)
+{
+    JSAddonId* addonId = xpc::NewAddonId(cx, addonIdStr);
+    if (!addonId)
+        return NS_ERROR_FAILURE;
+    if (!XPCWrappedNativeScope::SetAddonInterposition(cx, addonId, interposition))
+        return NS_ERROR_FAILURE;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::SetAddonCallInterposition(HandleValue target,
+                                                 JSContext* cx)
+{
+    NS_ENSURE_TRUE(target.isObject(), NS_ERROR_INVALID_ARG);
+    RootedObject targetObj(cx, &target.toObject());
+    targetObj = js::CheckedUnwrap(targetObj);
+    NS_ENSURE_TRUE(targetObj, NS_ERROR_INVALID_ARG);
+    XPCWrappedNativeScope* xpcScope = ObjectScope(targetObj);
+    NS_ENSURE_TRUE(xpcScope, NS_ERROR_INVALID_ARG);
+
+    xpcScope->SetAddonCallInterposition();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::AllowCPOWsInAddon(const nsACString& addonIdStr,
+                                         bool allow,
+                                         JSContext* cx)
+{
+    JSAddonId* addonId = xpc::NewAddonId(cx, addonIdStr);
+    if (!addonId)
+        return NS_ERROR_FAILURE;
+    if (!XPCWrappedNativeScope::AllowCPOWsInAddon(cx, addonId, allow))
+        return NS_ERROR_FAILURE;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents_Utils::Now(double* aRetval)
+{
+    bool isInconsistent = false;
+    TimeStamp start = TimeStamp::ProcessCreation(isInconsistent);
+    *aRetval = (TimeStamp::Now() - start).ToMilliseconds();
+    return NS_OK;
+}
+
+/***************************************************************************/
+/***************************************************************************/
+/***************************************************************************/
+
+
+nsXPCComponentsBase::nsXPCComponentsBase(XPCWrappedNativeScope* aScope)
+    :   mScope(aScope)
+{
+    MOZ_ASSERT(aScope, "aScope must not be null");
+}
+
+nsXPCComponents::nsXPCComponents(XPCWrappedNativeScope* aScope)
+    :   nsXPCComponentsBase(aScope)
+{
+}
+
+nsXPCComponentsBase::~nsXPCComponentsBase()
+{
+}
+
+nsXPCComponents::~nsXPCComponents()
+{
+}
+
+void
+nsXPCComponentsBase::ClearMembers()
+{
+    mInterfaces = nullptr;
+    mInterfacesByID = nullptr;
+    mResults = nullptr;
+}
+
+void
+nsXPCComponents::ClearMembers()
+{
+    mClasses = nullptr;
+    mClassesByID = nullptr;
+    mID = nullptr;
+    mException = nullptr;
+    mConstructor = nullptr;
+    mUtils = nullptr;
+
+    nsXPCComponentsBase::ClearMembers();
+}
+
+/*******************************************/
+#define XPC_IMPL_GET_OBJ_METHOD(_class, _n)                                   \
+NS_IMETHODIMP _class::Get##_n(nsIXPCComponents_##_n * *a##_n) {               \
+    NS_ENSURE_ARG_POINTER(a##_n);                                             \
+    if (!m##_n)                                                               \
+        m##_n = new nsXPCComponents_##_n();                                   \
+    RefPtr<nsXPCComponents_##_n> ret = m##_n;                               \
+    ret.forget(a##_n);                                                        \
+    return NS_OK;                                                             \
+}
+
+XPC_IMPL_GET_OBJ_METHOD(nsXPCComponentsBase, Interfaces)
+XPC_IMPL_GET_OBJ_METHOD(nsXPCComponentsBase, InterfacesByID)
+XPC_IMPL_GET_OBJ_METHOD(nsXPCComponents, Classes)
+XPC_IMPL_GET_OBJ_METHOD(nsXPCComponents, ClassesByID)
+XPC_IMPL_GET_OBJ_METHOD(nsXPCComponentsBase, Results)
+XPC_IMPL_GET_OBJ_METHOD(nsXPCComponents, ID)
+XPC_IMPL_GET_OBJ_METHOD(nsXPCComponents, Exception)
+XPC_IMPL_GET_OBJ_METHOD(nsXPCComponents, Constructor)
+XPC_IMPL_GET_OBJ_METHOD(nsXPCComponents, Utils)
+
+#undef XPC_IMPL_GET_OBJ_METHOD
+/*******************************************/
+
+NS_IMETHODIMP
+nsXPCComponentsBase::IsSuccessCode(nsresult result, bool* out)
+{
+    *out = NS_SUCCEEDED(result);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents::GetStack(nsIStackFrame * *aStack)
+{
+    nsresult rv;
+    nsXPConnect* xpc = nsXPConnect::XPConnect();
+    rv = xpc->GetCurrentJSStack(aStack);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsXPCComponents::GetManager(nsIComponentManager * *aManager)
+{
+    MOZ_ASSERT(aManager, "bad param");
+    return NS_GetComponentManager(aManager);
+}
+
+NS_IMETHODIMP
+nsXPCComponents::GetReturnCode(JSContext* aCx, MutableHandleValue aOut)
+{
+    nsresult res = XPCJSContext::Get()->GetPendingResult();
+    aOut.setNumber(static_cast<uint32_t>(res));
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCComponents::SetReturnCode(JSContext* aCx, HandleValue aCode)
+{
+    nsresult rv;
+    if (!ToUint32(aCx, aCode, (uint32_t*)&rv))
+        return NS_ERROR_FAILURE;
+    XPCJSContext::Get()->SetPendingResult(rv);
+    return NS_OK;
+}
+
+// static
+NS_IMETHODIMP nsXPCComponents::ReportError(HandleValue error, JSContext* cx)
+{
+    NS_WARNING("Components.reportError deprecated, use Components.utils.reportError");
+
+    nsCOMPtr<nsIXPCComponents_Utils> utils;
+    nsresult rv = GetUtils(getter_AddRefs(utils));
+    if (NS_FAILED(rv))
+        return rv;
+
+    return utils->ReportError(error, cx);
+}
+
+/**********************************************/
+
+class ComponentsSH : public nsIXPCScriptable
+{
+public:
+    explicit constexpr ComponentsSH(unsigned dummy)
+    {
+    }
+
+    // We don't actually inherit any ref counting infrastructure, but we don't
+    // need an nsAutoRefCnt member, so the _INHERITED macro is a hack to avoid
+    // having one.
+    NS_DECL_ISUPPORTS_INHERITED
+    NS_DECL_NSIXPCSCRIPTABLE
+    static nsresult Get(nsIXPCScriptable** helper)
+    {
+        *helper = &singleton;
+        return NS_OK;
+    }
+
+private:
+    static ComponentsSH singleton;
+};
+
+ComponentsSH ComponentsSH::singleton(0);
+
+// Singleton refcounting.
+NS_IMETHODIMP_(MozExternalRefCountType) ComponentsSH::AddRef(void) { return 1; }
+NS_IMETHODIMP_(MozExternalRefCountType) ComponentsSH::Release(void) { return 1; }
+
+NS_INTERFACE_MAP_BEGIN(ComponentsSH)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+#define NSXPCCOMPONENTSBASE_CID \
+{ 0xc62998e5, 0x95f1, 0x4058, \
+  { 0xa5, 0x09, 0xec, 0x21, 0x66, 0x18, 0x92, 0xb9 } }
+
+#define NSXPCCOMPONENTS_CID \
+{ 0x3649f405, 0xf0ec, 0x4c28, \
+    { 0xae, 0xb0, 0xaf, 0x9a, 0x51, 0xe4, 0x4c, 0x81 } }
+
+NS_IMPL_CLASSINFO(nsXPCComponentsBase, &ComponentsSH::Get, nsIClassInfo::DOM_OBJECT, NSXPCCOMPONENTSBASE_CID)
+NS_IMPL_ISUPPORTS_CI(nsXPCComponentsBase, nsIXPCComponentsBase)
+
+NS_IMPL_CLASSINFO(nsXPCComponents, &ComponentsSH::Get, nsIClassInfo::DOM_OBJECT, NSXPCCOMPONENTS_CID)
+// Below is more or less what NS_IMPL_ISUPPORTS_CI_INHERITED1 would look like
+// if it existed.
+NS_IMPL_ADDREF_INHERITED(nsXPCComponents, nsXPCComponentsBase)
+NS_IMPL_RELEASE_INHERITED(nsXPCComponents, nsXPCComponentsBase)
+NS_INTERFACE_MAP_BEGIN(nsXPCComponents)
+    NS_INTERFACE_MAP_ENTRY(nsIXPCComponents)
+    NS_IMPL_QUERY_CLASSINFO(nsXPCComponents)
+NS_INTERFACE_MAP_END_INHERITING(nsXPCComponentsBase)
+NS_IMPL_CI_INTERFACE_GETTER(nsXPCComponents, nsIXPCComponents)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us
+#define XPC_MAP_CLASSNAME           ComponentsSH
+#define XPC_MAP_QUOTED_CLASSNAME   "nsXPCComponents"
+#define                             XPC_MAP_WANT_PRECREATE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+NS_IMETHODIMP
+ComponentsSH::PreCreate(nsISupports* nativeObj, JSContext* cx, JSObject* globalObj, JSObject** parentObj)
+{
+  nsXPCComponentsBase* self = static_cast<nsXPCComponentsBase*>(nativeObj);
+  // this should never happen
+  if (!self->GetScope()) {
+      NS_WARNING("mScope must not be null when nsXPCComponents::PreCreate is called");
+      return NS_ERROR_FAILURE;
+  }
+  *parentObj = self->GetScope()->GetGlobalJSObject();
+  return NS_OK;
+}
diff --git a/js/xpconnect/src/XPCConvert.cpp b/js/xpconnect/src/XPCConvert.cpp
new file mode 100644
index 000000000..37932b452
--- /dev/null
+++ b/js/xpconnect/src/XPCConvert.cpp
@@ -0,0 +1,1799 @@
+/* -*- 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/. */
+
+/* Data conversion between native and JavaScript types. */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Range.h"
+
+#include "xpcprivate.h"
+#include "nsIAtom.h"
+#include "nsWrapperCache.h"
+#include "nsJSUtils.h"
+#include "nsQueryObject.h"
+#include "WrapperFactory.h"
+
+#include "nsWrapperCacheInlines.h"
+
+#include "jsapi.h"
+#include "jsfriendapi.h"
+#include "js/CharacterEncoding.h"
+#include "jsprf.h"
+
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/PrimitiveConversions.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
+
+using namespace xpc;
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace JS;
+
+//#define STRICT_CHECK_OF_UNICODE
+#ifdef STRICT_CHECK_OF_UNICODE
+#define ILLEGAL_RANGE(c) (0!=((c) & 0xFF80))
+#else // STRICT_CHECK_OF_UNICODE
+#define ILLEGAL_RANGE(c) (0!=((c) & 0xFF00))
+#endif // STRICT_CHECK_OF_UNICODE
+
+#define ILLEGAL_CHAR_RANGE(c) (0!=((c) & 0x80))
+
+/***********************************************************/
+
+// static
+bool
+XPCConvert::IsMethodReflectable(const XPTMethodDescriptor& info)
+{
+    if (XPT_MD_IS_NOTXPCOM(info.flags) || XPT_MD_IS_HIDDEN(info.flags))
+        return false;
+
+    for (int i = info.num_args-1; i >= 0; i--) {
+        const nsXPTParamInfo& param = info.params[i];
+        const nsXPTType& type = param.GetType();
+
+        // Reflected methods can't use native types. All native types end up
+        // getting tagged as void*, so this check is easy.
+        if (type.TagPart() == nsXPTType::T_VOID)
+            return false;
+    }
+    return true;
+}
+
+static JSObject*
+UnwrapNativeCPOW(nsISupports* wrapper)
+{
+    nsCOMPtr<nsIXPConnectWrappedJS> underware = do_QueryInterface(wrapper);
+    if (underware) {
+        JSObject* mainObj = underware->GetJSObject();
+        if (mainObj && mozilla::jsipc::IsWrappedCPOW(mainObj))
+            return mainObj;
+    }
+    return nullptr;
+}
+
+/***************************************************************************/
+
+// static
+bool
+XPCConvert::GetISupportsFromJSObject(JSObject* obj, nsISupports** iface)
+{
+    const JSClass* jsclass = js::GetObjectJSClass(obj);
+    MOZ_ASSERT(jsclass, "obj has no class");
+    if (jsclass &&
+        (jsclass->flags & JSCLASS_HAS_PRIVATE) &&
+        (jsclass->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS)) {
+        *iface = (nsISupports*) xpc_GetJSPrivate(obj);
+        return true;
+    }
+    *iface = UnwrapDOMObjectToISupports(obj);
+    return !!*iface;
+}
+
+/***************************************************************************/
+
+// static
+bool
+XPCConvert::NativeData2JS(MutableHandleValue d, const void* s,
+                          const nsXPTType& type, const nsID* iid, nsresult* pErr)
+{
+    NS_PRECONDITION(s, "bad param");
+
+    AutoJSContext cx;
+    if (pErr)
+        *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE;
+
+    switch (type.TagPart()) {
+    case nsXPTType::T_I8    :
+        d.setInt32(*static_cast<const int8_t*>(s));
+        return true;
+    case nsXPTType::T_I16   :
+        d.setInt32(*static_cast<const int16_t*>(s));
+        return true;
+    case nsXPTType::T_I32   :
+        d.setInt32(*static_cast<const int32_t*>(s));
+        return true;
+    case nsXPTType::T_I64   :
+        d.setNumber(static_cast<double>(*static_cast<const int64_t*>(s)));
+        return true;
+    case nsXPTType::T_U8    :
+        d.setInt32(*static_cast<const uint8_t*>(s));
+        return true;
+    case nsXPTType::T_U16   :
+        d.setInt32(*static_cast<const uint16_t*>(s));
+        return true;
+    case nsXPTType::T_U32   :
+        d.setNumber(*static_cast<const uint32_t*>(s));
+        return true;
+    case nsXPTType::T_U64   :
+        d.setNumber(static_cast<double>(*static_cast<const uint64_t*>(s)));
+        return true;
+    case nsXPTType::T_FLOAT :
+        d.setNumber(*static_cast<const float*>(s));
+        return true;
+    case nsXPTType::T_DOUBLE:
+        d.setNumber(*static_cast<const double*>(s));
+        return true;
+    case nsXPTType::T_BOOL  :
+        d.setBoolean(*static_cast<const bool*>(s));
+        return true;
+    case nsXPTType::T_CHAR  :
+    {
+        char p = *static_cast<const char*>(s);
+
+#ifdef STRICT_CHECK_OF_UNICODE
+        MOZ_ASSERT(! ILLEGAL_CHAR_RANGE(p) , "passing non ASCII data");
+#endif // STRICT_CHECK_OF_UNICODE
+
+        JSString* str = JS_NewStringCopyN(cx, &p, 1);
+        if (!str)
+            return false;
+
+        d.setString(str);
+        return true;
+    }
+    case nsXPTType::T_WCHAR :
+    {
+        char16_t p = *static_cast<const char16_t*>(s);
+
+        JSString* str = JS_NewUCStringCopyN(cx, &p, 1);
+        if (!str)
+            return false;
+
+        d.setString(str);
+        return true;
+    }
+
+    case nsXPTType::T_JSVAL :
+    {
+        d.set(*static_cast<const Value*>(s));
+        return JS_WrapValue(cx, d);
+    }
+
+    case nsXPTType::T_VOID:
+        XPC_LOG_ERROR(("XPCConvert::NativeData2JS : void* params not supported"));
+        return false;
+
+    case nsXPTType::T_IID:
+    {
+        nsID* iid2 = *static_cast<nsID* const*>(s);
+        if (!iid2) {
+            d.setNull();
+            return true;
+        }
+
+        RootedObject scope(cx, JS::CurrentGlobalOrNull(cx));
+        JSObject* obj = xpc_NewIDObject(cx, scope, *iid2);
+        if (!obj)
+            return false;
+
+        d.setObject(*obj);
+        return true;
+    }
+
+    case nsXPTType::T_ASTRING:
+        // Fall through to T_DOMSTRING case
+
+    case nsXPTType::T_DOMSTRING:
+    {
+        const nsAString* p = *static_cast<const nsAString* const*>(s);
+        if (!p || p->IsVoid()) {
+            d.setNull();
+            return true;
+        }
+
+        nsStringBuffer* buf;
+        if (!XPCStringConvert::ReadableToJSVal(cx, *p, &buf, d))
+            return false;
+        if (buf)
+            buf->AddRef();
+        return true;
+    }
+
+    case nsXPTType::T_CHAR_STR:
+    {
+        const char* p = *static_cast<const char* const*>(s);
+        if (!p) {
+            d.setNull();
+            return true;
+        }
+
+#ifdef STRICT_CHECK_OF_UNICODE
+        bool isAscii = true;
+        for (char* t = p; *t && isAscii; t++) {
+          if (ILLEGAL_CHAR_RANGE(*t))
+              isAscii = false;
+        }
+        MOZ_ASSERT(isAscii, "passing non ASCII data");
+#endif // STRICT_CHECK_OF_UNICODE
+
+        JSString* str = JS_NewStringCopyZ(cx, p);
+        if (!str)
+            return false;
+
+        d.setString(str);
+        return true;
+    }
+
+    case nsXPTType::T_WCHAR_STR:
+    {
+        const char16_t* p = *static_cast<const char16_t* const*>(s);
+        if (!p) {
+            d.setNull();
+            return true;
+        }
+
+        JSString* str = JS_NewUCStringCopyZ(cx, p);
+        if (!str)
+            return false;
+
+        d.setString(str);
+        return true;
+    }
+    case nsXPTType::T_UTF8STRING:
+    {
+        const nsACString* utf8String = *static_cast<const nsACString* const*>(s);
+
+        if (!utf8String || utf8String->IsVoid()) {
+            d.setNull();
+            return true;
+        }
+
+        if (utf8String->IsEmpty()) {
+            d.set(JS_GetEmptyStringValue(cx));
+            return true;
+        }
+
+        const uint32_t len = CalcUTF8ToUnicodeLength(*utf8String);
+        // The cString is not empty at this point, but the calculated
+        // UTF-16 length is zero, meaning no valid conversion exists.
+        if (!len)
+            return false;
+
+        const size_t buffer_size = (len + 1) * sizeof(char16_t);
+        char16_t* buffer =
+            static_cast<char16_t*>(JS_malloc(cx, buffer_size));
+        if (!buffer)
+            return false;
+
+        uint32_t copied;
+        if (!UTF8ToUnicodeBuffer(*utf8String, buffer, &copied) ||
+            len != copied) {
+            // Copy or conversion during copy failed. Did not copy the
+            // whole string.
+            JS_free(cx, buffer);
+            return false;
+        }
+
+        // JS_NewUCString takes ownership on success, i.e. a
+        // successful call will make it the responsiblity of the JS VM
+        // to free the buffer.
+        JSString* str = JS_NewUCString(cx, buffer, len);
+        if (!str) {
+            JS_free(cx, buffer);
+            return false;
+        }
+
+        d.setString(str);
+        return true;
+    }
+    case nsXPTType::T_CSTRING:
+    {
+        const nsACString* cString = *static_cast<const nsACString* const*>(s);
+
+        if (!cString || cString->IsVoid()) {
+            d.setNull();
+            return true;
+        }
+
+        // c-strings (binary blobs) are deliberately not converted from
+        // UTF-8 to UTF-16. T_UTF8Sting is for UTF-8 encoded strings
+        // with automatic conversion.
+        JSString* str = JS_NewStringCopyN(cx, cString->Data(),
+                                          cString->Length());
+        if (!str)
+            return false;
+
+        d.setString(str);
+        return true;
+    }
+
+    case nsXPTType::T_INTERFACE:
+    case nsXPTType::T_INTERFACE_IS:
+    {
+        nsISupports* iface = *static_cast<nsISupports* const*>(s);
+        if (!iface) {
+            d.setNull();
+            return true;
+        }
+
+        if (iid->Equals(NS_GET_IID(nsIVariant))) {
+            nsCOMPtr<nsIVariant> variant = do_QueryInterface(iface);
+            if (!variant)
+                return false;
+
+            return XPCVariant::VariantDataToJS(variant,
+                                               pErr, d);
+        }
+
+        xpcObjectHelper helper(iface);
+        return NativeInterface2JSObject(d, nullptr, helper, iid, true, pErr);
+    }
+
+    default:
+        NS_ERROR("bad type");
+        return false;
+    }
+    return true;
+}
+
+/***************************************************************************/
+
+#ifdef DEBUG
+static bool
+CheckChar16InCharRange(char16_t c)
+{
+    if (ILLEGAL_RANGE(c)) {
+        /* U+0080/U+0100 - U+FFFF data lost. */
+        static const size_t MSG_BUF_SIZE = 64;
+        char msg[MSG_BUF_SIZE];
+        snprintf(msg, MSG_BUF_SIZE, "char16_t out of char range; high bits of data lost: 0x%x", int(c));
+        NS_WARNING(msg);
+        return false;
+    }
+
+    return true;
+}
+
+template<typename CharT>
+static void
+CheckCharsInCharRange(const CharT* chars, size_t len)
+{
+    for (size_t i = 0; i < len; i++) {
+        if (!CheckChar16InCharRange(chars[i]))
+            break;
+    }
+}
+#endif
+
+template<typename T>
+bool ConvertToPrimitive(JSContext* cx, HandleValue v, T* retval)
+{
+    return ValueToPrimitive<T, eDefault>(cx, v, retval);
+}
+
+// static
+bool
+XPCConvert::JSData2Native(void* d, HandleValue s,
+                          const nsXPTType& type,
+                          const nsID* iid,
+                          nsresult* pErr)
+{
+    NS_PRECONDITION(d, "bad param");
+
+    AutoJSContext cx;
+    if (pErr)
+        *pErr = NS_ERROR_XPC_BAD_CONVERT_JS;
+
+    switch (type.TagPart()) {
+    case nsXPTType::T_I8     :
+        return ConvertToPrimitive(cx, s, static_cast<int8_t*>(d));
+    case nsXPTType::T_I16    :
+        return ConvertToPrimitive(cx, s, static_cast<int16_t*>(d));
+    case nsXPTType::T_I32    :
+        return ConvertToPrimitive(cx, s, static_cast<int32_t*>(d));
+    case nsXPTType::T_I64    :
+        return ConvertToPrimitive(cx, s, static_cast<int64_t*>(d));
+    case nsXPTType::T_U8     :
+        return ConvertToPrimitive(cx, s, static_cast<uint8_t*>(d));
+    case nsXPTType::T_U16    :
+        return ConvertToPrimitive(cx, s, static_cast<uint16_t*>(d));
+    case nsXPTType::T_U32    :
+        return ConvertToPrimitive(cx, s, static_cast<uint32_t*>(d));
+    case nsXPTType::T_U64    :
+        return ConvertToPrimitive(cx, s, static_cast<uint64_t*>(d));
+    case nsXPTType::T_FLOAT  :
+        return ConvertToPrimitive(cx, s, static_cast<float*>(d));
+    case nsXPTType::T_DOUBLE :
+        return ConvertToPrimitive(cx, s, static_cast<double*>(d));
+    case nsXPTType::T_BOOL   :
+        return ConvertToPrimitive(cx, s, static_cast<bool*>(d));
+    case nsXPTType::T_CHAR   :
+    {
+        JSString* str = ToString(cx, s);
+        if (!str) {
+            return false;
+        }
+
+        char16_t ch;
+        if (JS_GetStringLength(str) == 0) {
+            ch = 0;
+        } else {
+            if (!JS_GetStringCharAt(cx, str, 0, &ch))
+                return false;
+        }
+#ifdef DEBUG
+        CheckChar16InCharRange(ch);
+#endif
+        *((char*)d) = char(ch);
+        break;
+    }
+    case nsXPTType::T_WCHAR  :
+    {
+        JSString* str;
+        if (!(str = ToString(cx, s))) {
+            return false;
+        }
+        size_t length = JS_GetStringLength(str);
+        if (length == 0) {
+            *((uint16_t*)d) = 0;
+            break;
+        }
+
+        char16_t ch;
+        if (!JS_GetStringCharAt(cx, str, 0, &ch))
+            return false;
+
+        *((uint16_t*)d) = uint16_t(ch);
+        break;
+    }
+    case nsXPTType::T_JSVAL :
+        *((Value*)d) = s;
+        break;
+    case nsXPTType::T_VOID:
+        XPC_LOG_ERROR(("XPCConvert::JSData2Native : void* params not supported"));
+        NS_ERROR("void* params not supported");
+        return false;
+    case nsXPTType::T_IID:
+    {
+        const nsID* pid = nullptr;
+
+        // There's no good reason to pass a null IID.
+        if (s.isNullOrUndefined()) {
+            if (pErr)
+                *pErr = NS_ERROR_XPC_BAD_CONVERT_JS;
+            return false;
+        }
+
+        if (!s.isObject() ||
+            (!(pid = xpc_JSObjectToID(cx, &s.toObject()))) ||
+            (!(pid = (const nsID*) nsMemory::Clone(pid, sizeof(nsID))))) {
+            return false;
+        }
+        *((const nsID**)d) = pid;
+        return true;
+    }
+
+    case nsXPTType::T_ASTRING:
+    {
+        if (s.isUndefined()) {
+            (**((nsAString**)d)).SetIsVoid(true);
+            return true;
+        }
+        MOZ_FALLTHROUGH;
+    }
+    case nsXPTType::T_DOMSTRING:
+    {
+        if (s.isNull()) {
+            (**((nsAString**)d)).SetIsVoid(true);
+            return true;
+        }
+        size_t length = 0;
+        JSString* str = nullptr;
+        if (!s.isUndefined()) {
+            str = ToString(cx, s);
+            if (!str)
+                return false;
+
+            length = JS_GetStringLength(str);
+            if (!length) {
+                (**((nsAString**)d)).Truncate();
+                return true;
+            }
+        }
+
+        nsAString* ws = *((nsAString**)d);
+
+        if (!str) {
+            ws->AssignLiteral(u"undefined");
+        } else if (XPCStringConvert::IsDOMString(str)) {
+            // The characters represent an existing nsStringBuffer that
+            // was shared by XPCStringConvert::ReadableToJSVal.
+            const char16_t* chars = JS_GetTwoByteExternalStringChars(str);
+            if (chars[length] == '\0') {
+                // Safe to share the buffer.
+                nsStringBuffer::FromData((void*)chars)->ToString(length, *ws);
+            } else {
+                // We have to copy to ensure null-termination.
+                ws->Assign(chars, length);
+            }
+        } else if (XPCStringConvert::IsLiteral(str)) {
+            // The characters represent a literal char16_t string constant
+            // compiled into libxul, such as the string "undefined" above.
+            const char16_t* chars = JS_GetTwoByteExternalStringChars(str);
+            ws->AssignLiteral(chars, length);
+        } else {
+            if (!AssignJSString(cx, *ws, str))
+                return false;
+        }
+        return true;
+    }
+
+    case nsXPTType::T_CHAR_STR:
+    {
+        if (s.isUndefined() || s.isNull()) {
+            *((char**)d) = nullptr;
+            return true;
+        }
+
+        JSString* str = ToString(cx, s);
+        if (!str) {
+            return false;
+        }
+#ifdef DEBUG
+        if (JS_StringHasLatin1Chars(str)) {
+            size_t len;
+            AutoCheckCannotGC nogc;
+            const Latin1Char* chars = JS_GetLatin1StringCharsAndLength(cx, nogc, str, &len);
+            if (chars)
+                CheckCharsInCharRange(chars, len);
+        } else {
+            size_t len;
+            AutoCheckCannotGC nogc;
+            const char16_t* chars = JS_GetTwoByteStringCharsAndLength(cx, nogc, str, &len);
+            if (chars)
+                CheckCharsInCharRange(chars, len);
+        }
+#endif // DEBUG
+        size_t length = JS_GetStringEncodingLength(cx, str);
+        if (length == size_t(-1)) {
+            return false;
+        }
+        char* buffer = static_cast<char*>(moz_xmalloc(length + 1));
+        if (!buffer) {
+            return false;
+        }
+        JS_EncodeStringToBuffer(cx, str, buffer, length);
+        buffer[length] = '\0';
+        *((void**)d) = buffer;
+        return true;
+    }
+
+    case nsXPTType::T_WCHAR_STR:
+    {
+        JSString* str;
+
+        if (s.isUndefined() || s.isNull()) {
+            *((char16_t**)d) = nullptr;
+            return true;
+        }
+
+        if (!(str = ToString(cx, s))) {
+            return false;
+        }
+        int len = JS_GetStringLength(str);
+        int byte_len = (len+1)*sizeof(char16_t);
+        if (!(*((void**)d) = moz_xmalloc(byte_len))) {
+            // XXX should report error
+            return false;
+        }
+        mozilla::Range<char16_t> destChars(*((char16_t**)d), len + 1);
+        if (!JS_CopyStringChars(cx, destChars, str))
+            return false;
+        destChars[len] = 0;
+
+        return true;
+    }
+
+    case nsXPTType::T_UTF8STRING:
+    {
+        if (s.isNull() || s.isUndefined()) {
+            nsCString* rs = *((nsCString**)d);
+            rs->SetIsVoid(true);
+            return true;
+        }
+
+        // The JS val is neither null nor void...
+        JSString* str = ToString(cx, s);
+        if (!str)
+            return false;
+
+        size_t length = JS_GetStringLength(str);
+        if (!length) {
+            nsCString* rs = *((nsCString**)d);
+            rs->Truncate();
+            return true;
+        }
+
+        JSFlatString* flat = JS_FlattenString(cx, str);
+        if (!flat)
+            return false;
+
+        size_t utf8Length = JS::GetDeflatedUTF8StringLength(flat);
+        nsACString* rs = *((nsACString**)d);
+        rs->SetLength(utf8Length);
+
+        JS::DeflateStringToUTF8Buffer(flat, mozilla::RangedPtr<char>(rs->BeginWriting(), utf8Length));
+
+        return true;
+    }
+
+    case nsXPTType::T_CSTRING:
+    {
+        if (s.isNull() || s.isUndefined()) {
+            nsACString* rs = *((nsACString**)d);
+            rs->SetIsVoid(true);
+            return true;
+        }
+
+        // The JS val is neither null nor void...
+        JSString* str = ToString(cx, s);
+        if (!str) {
+            return false;
+        }
+
+        size_t length = JS_GetStringEncodingLength(cx, str);
+        if (length == size_t(-1)) {
+            return false;
+        }
+
+        if (!length) {
+            nsCString* rs = *((nsCString**)d);
+            rs->Truncate();
+            return true;
+        }
+
+        nsACString* rs = *((nsACString**)d);
+        rs->SetLength(uint32_t(length));
+        if (rs->Length() != uint32_t(length)) {
+            return false;
+        }
+        JS_EncodeStringToBuffer(cx, str, rs->BeginWriting(), length);
+
+        return true;
+    }
+
+    case nsXPTType::T_INTERFACE:
+    case nsXPTType::T_INTERFACE_IS:
+    {
+        MOZ_ASSERT(iid,"can't do interface conversions without iid");
+
+        if (iid->Equals(NS_GET_IID(nsIVariant))) {
+            nsCOMPtr<nsIVariant> variant = XPCVariant::newVariant(cx, s);
+            if (!variant)
+                return false;
+
+            variant.forget(static_cast<nsISupports**>(d));
+            return true;
+        } else if (iid->Equals(NS_GET_IID(nsIAtom)) && s.isString()) {
+            // We're trying to pass a string as an nsIAtom.  Let's atomize!
+            JSString* str = s.toString();
+            nsAutoJSString autoStr;
+            if (!autoStr.init(cx, str)) {
+                if (pErr)
+                    *pErr = NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF;
+                return false;
+            }
+            nsCOMPtr<nsIAtom> atom = NS_Atomize(autoStr);
+            atom.forget((nsISupports**)d);
+            return true;
+        }
+        //else ...
+
+        if (s.isNullOrUndefined()) {
+            *((nsISupports**)d) = nullptr;
+            return true;
+        }
+
+        // only wrap JSObjects
+        if (!s.isObject()) {
+            if (pErr && s.isInt32() && 0 == s.toInt32())
+                *pErr = NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL;
+            return false;
+        }
+
+        RootedObject src(cx, &s.toObject());
+        return JSObject2NativeInterface((void**)d, src, iid, nullptr, pErr);
+    }
+    default:
+        NS_ERROR("bad type");
+        return false;
+    }
+    return true;
+}
+
+static inline bool
+CreateHolderIfNeeded(HandleObject obj, MutableHandleValue d,
+                     nsIXPConnectJSObjectHolder** dest)
+{
+    if (dest) {
+        if (!obj)
+            return false;
+        RefPtr<XPCJSObjectHolder> objHolder = new XPCJSObjectHolder(obj);
+        objHolder.forget(dest);
+    }
+
+    d.setObjectOrNull(obj);
+
+    return true;
+}
+
+/***************************************************************************/
+// static
+bool
+XPCConvert::NativeInterface2JSObject(MutableHandleValue d,
+                                     nsIXPConnectJSObjectHolder** dest,
+                                     xpcObjectHelper& aHelper,
+                                     const nsID* iid,
+                                     bool allowNativeWrapper,
+                                     nsresult* pErr)
+{
+    if (!iid)
+        iid = &NS_GET_IID(nsISupports);
+
+    d.setNull();
+    if (dest)
+        *dest = nullptr;
+    if (!aHelper.Object())
+        return true;
+    if (pErr)
+        *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE;
+
+    // We used to have code here that unwrapped and simply exposed the
+    // underlying JSObject. That caused anomolies when JSComponents were
+    // accessed from other JS code - they didn't act like other xpconnect
+    // wrapped components. So, instead, we create "double wrapped" objects
+    // (that means an XPCWrappedNative around an nsXPCWrappedJS). This isn't
+    // optimal -- we could detect this and roll the functionality into a
+    // single wrapper, but the current solution is good enough for now.
+    AutoJSContext cx;
+    XPCWrappedNativeScope* xpcscope = ObjectScope(JS::CurrentGlobalOrNull(cx));
+    if (!xpcscope)
+        return false;
+
+    // First, see if this object supports the wrapper cache.
+    // Note: If |cache->IsDOMBinding()| is true, then it means that the object
+    // implementing it doesn't want a wrapped native as its JS Object, but
+    // instead it provides its own proxy object. In that case, the object
+    // to use is found as cache->GetWrapper(). If that is null, then the
+    // object will create (and fill the cache) from its WrapObject call.
+    nsWrapperCache* cache = aHelper.GetWrapperCache();
+
+    RootedObject flat(cx, cache ? cache->GetWrapper() : nullptr);
+    if (!flat && cache && cache->IsDOMBinding()) {
+        RootedObject global(cx, xpcscope->GetGlobalJSObject());
+        js::AssertSameCompartment(cx, global);
+        flat = cache->WrapObject(cx, nullptr);
+        if (!flat)
+            return false;
+    }
+    if (flat) {
+        if (allowNativeWrapper && !JS_WrapObject(cx, &flat))
+            return false;
+        return CreateHolderIfNeeded(flat, d, dest);
+    }
+
+#ifdef SPIDERMONKEY_PROMISE
+    if (iid->Equals(NS_GET_IID(nsISupports))) {
+        // Check for a Promise being returned via nsISupports.  In that
+        // situation, we want to dig out its underlying JS object and return
+        // that.
+        RefPtr<Promise> promise = do_QueryObject(aHelper.Object());
+        if (promise) {
+            flat = promise->PromiseObj();
+            if (!JS_WrapObject(cx, &flat))
+                return false;
+            return CreateHolderIfNeeded(flat, d, dest);
+        }
+    }
+#endif // SPIDERMONKEY_PROMISE
+
+    // Don't double wrap CPOWs. This is a temporary measure for compatibility
+    // with objects that don't provide necessary QIs (such as objects under
+    // the new DOM bindings). We expect the other side of the CPOW to have
+    // the appropriate wrappers in place.
+    RootedObject cpow(cx, UnwrapNativeCPOW(aHelper.Object()));
+    if (cpow) {
+        if (!JS_WrapObject(cx, &cpow))
+            return false;
+        d.setObject(*cpow);
+        return true;
+    }
+
+    // Go ahead and create an XPCWrappedNative for this object.
+    RefPtr<XPCNativeInterface> iface =
+        XPCNativeInterface::GetNewOrUsed(iid);
+    if (!iface)
+        return false;
+
+    RefPtr<XPCWrappedNative> wrapper;
+    nsresult rv = XPCWrappedNative::GetNewOrUsed(aHelper, xpcscope, iface,
+                                                 getter_AddRefs(wrapper));
+    if (NS_FAILED(rv) && pErr)
+        *pErr = rv;
+
+    // If creating the wrapped native failed, then return early.
+    if (NS_FAILED(rv) || !wrapper)
+        return false;
+
+    // If we're not creating security wrappers, we can return the
+    // XPCWrappedNative as-is here.
+    flat = wrapper->GetFlatJSObject();
+    if (!allowNativeWrapper) {
+        d.setObjectOrNull(flat);
+        if (dest)
+            wrapper.forget(dest);
+        if (pErr)
+            *pErr = NS_OK;
+        return true;
+    }
+
+    // The call to wrap here handles both cross-compartment and same-compartment
+    // security wrappers.
+    RootedObject original(cx, flat);
+    if (!JS_WrapObject(cx, &flat))
+        return false;
+
+    d.setObjectOrNull(flat);
+
+    if (dest) {
+        // The wrapper still holds the original flat object.
+        if (flat == original) {
+            wrapper.forget(dest);
+        } else {
+            if (!flat)
+                return false;
+            RefPtr<XPCJSObjectHolder> objHolder = new XPCJSObjectHolder(flat);
+            objHolder.forget(dest);
+        }
+    }
+
+    if (pErr)
+        *pErr = NS_OK;
+
+    return true;
+}
+
+/***************************************************************************/
+
+// static
+bool
+XPCConvert::JSObject2NativeInterface(void** dest, HandleObject src,
+                                     const nsID* iid,
+                                     nsISupports* aOuter,
+                                     nsresult* pErr)
+{
+    MOZ_ASSERT(dest, "bad param");
+    MOZ_ASSERT(src, "bad param");
+    MOZ_ASSERT(iid, "bad param");
+
+    AutoJSContext cx;
+    JSAutoCompartment ac(cx, src);
+
+    *dest = nullptr;
+     if (pErr)
+        *pErr = NS_ERROR_XPC_BAD_CONVERT_JS;
+
+    nsISupports* iface;
+
+    if (!aOuter) {
+        // Note that if we have a non-null aOuter then it means that we are
+        // forcing the creation of a wrapper even if the object *is* a
+        // wrappedNative or other wise has 'nsISupportness'.
+        // This allows wrapJSAggregatedToNative to work.
+
+        // If we're looking at a security wrapper, see now if we're allowed to
+        // pass it to C++. If we are, then fall through to the code below. If
+        // we aren't, throw an exception eagerly.
+        //
+        // NB: It's very important that we _don't_ unwrap in the aOuter case,
+        // because the caller may explicitly want to create the XPCWrappedJS
+        // around a security wrapper. XBL does this with Xrays from the XBL
+        // scope - see nsBindingManager::GetBindingImplementation.
+        //
+        // It's also very important that "inner" be rooted here.
+        RootedObject inner(cx,
+                           js::CheckedUnwrap(src,
+                                             /* stopAtWindowProxy = */ false));
+        if (!inner) {
+            if (pErr)
+                *pErr = NS_ERROR_XPC_SECURITY_MANAGER_VETO;
+            return false;
+        }
+
+        // Is this really a native xpcom object with a wrapper?
+        XPCWrappedNative* wrappedNative = nullptr;
+        if (IS_WN_REFLECTOR(inner))
+            wrappedNative = XPCWrappedNative::Get(inner);
+        if (wrappedNative) {
+            iface = wrappedNative->GetIdentityObject();
+            return NS_SUCCEEDED(iface->QueryInterface(*iid, dest));
+        }
+        // else...
+
+        // Deal with slim wrappers here.
+        if (GetISupportsFromJSObject(inner ? inner : src, &iface)) {
+            if (iface && NS_SUCCEEDED(iface->QueryInterface(*iid, dest))) {
+                return true;
+            }
+
+            // If that failed, and iid is for mozIDOMWindowProxy, we actually
+            // want the outer!
+            if (iid->Equals(NS_GET_IID(mozIDOMWindowProxy))) {
+                if (nsCOMPtr<mozIDOMWindow> inner = do_QueryInterface(iface)) {
+                    iface = nsPIDOMWindowInner::From(inner)->GetOuterWindow();
+                    return NS_SUCCEEDED(iface->QueryInterface(*iid, dest));
+                }
+            }
+
+            return false;
+        }
+
+#ifdef SPIDERMONKEY_PROMISE
+        // Deal with Promises being passed as nsISupports.  In that situation we
+        // want to create a dom::Promise and use that.
+        if (iid->Equals(NS_GET_IID(nsISupports))) {
+            RootedObject innerObj(cx, inner);
+            if (IsPromiseObject(innerObj)) {
+                nsIGlobalObject* glob = NativeGlobal(innerObj);
+                RefPtr<Promise> p = Promise::CreateFromExisting(glob, innerObj);
+                return p && NS_SUCCEEDED(p->QueryInterface(*iid, dest));
+            }
+        }
+#endif // SPIDERMONKEY_PROMISE
+    }
+
+    RefPtr<nsXPCWrappedJS> wrapper;
+    nsresult rv = nsXPCWrappedJS::GetNewOrUsed(src, *iid, getter_AddRefs(wrapper));
+    if (pErr)
+        *pErr = rv;
+
+    if (NS_FAILED(rv) || !wrapper)
+        return false;
+
+    // If the caller wanted to aggregate this JS object to a native,
+    // attach it to the wrapper. Note that we allow a maximum of one
+    // aggregated native for a given XPCWrappedJS.
+    if (aOuter)
+        wrapper->SetAggregatedNativeObject(aOuter);
+
+    // We need to go through the QueryInterface logic to make this return
+    // the right thing for the various 'special' interfaces; e.g.
+    // nsIPropertyBag. We must use AggregatedQueryInterface in cases where
+    // there is an outer to avoid nasty recursion.
+    rv = aOuter ? wrapper->AggregatedQueryInterface(*iid, dest) :
+        wrapper->QueryInterface(*iid, dest);
+    if (pErr)
+        *pErr = rv;
+    return NS_SUCCEEDED(rv);
+}
+
+/***************************************************************************/
+/***************************************************************************/
+
+// static
+nsresult
+XPCConvert::ConstructException(nsresult rv, const char* message,
+                               const char* ifaceName, const char* methodName,
+                               nsISupports* data,
+                               nsIException** exceptn,
+                               JSContext* cx,
+                               Value* jsExceptionPtr)
+{
+    MOZ_ASSERT(!cx == !jsExceptionPtr, "Expected cx and jsExceptionPtr to cooccur.");
+
+    static const char format[] = "\'%s\' when calling method: [%s::%s]";
+    const char * msg = message;
+    nsXPIDLString xmsg;
+    nsAutoCString sxmsg;
+
+    nsCOMPtr<nsIScriptError> errorObject = do_QueryInterface(data);
+    if (errorObject) {
+        if (NS_SUCCEEDED(errorObject->GetMessageMoz(getter_Copies(xmsg)))) {
+            CopyUTF16toUTF8(xmsg, sxmsg);
+            msg = sxmsg.get();
+        }
+    }
+    if (!msg)
+        if (!nsXPCException::NameAndFormatForNSResult(rv, nullptr, &msg) || ! msg)
+            msg = "<error>";
+
+    nsCString msgStr(msg);
+    if (ifaceName && methodName)
+        msgStr.AppendPrintf(format, msg, ifaceName, methodName);
+
+    RefPtr<Exception> e = new Exception(msgStr, rv, EmptyCString(), nullptr, data);
+
+    if (cx && jsExceptionPtr) {
+        e->StowJSVal(*jsExceptionPtr);
+    }
+
+    e.forget(exceptn);
+    return NS_OK;
+}
+
+/********************************/
+
+class MOZ_STACK_CLASS AutoExceptionRestorer
+{
+public:
+    AutoExceptionRestorer(JSContext* cx, const Value& v)
+        : mContext(cx), tvr(cx, v)
+    {
+        JS_ClearPendingException(mContext);
+    }
+
+    ~AutoExceptionRestorer()
+    {
+        JS_SetPendingException(mContext, tvr);
+    }
+
+private:
+    JSContext * const mContext;
+    RootedValue tvr;
+};
+
+static nsresult
+JSErrorToXPCException(const char* toStringResult,
+                      const char* ifaceName,
+                      const char* methodName,
+                      const JSErrorReport* report,
+                      nsIException** exceptn)
+{
+    AutoJSContext cx;
+    nsresult rv = NS_ERROR_FAILURE;
+    RefPtr<nsScriptError> data;
+    if (report) {
+        nsAutoString bestMessage;
+        if (report && report->message()) {
+            CopyUTF8toUTF16(report->message().c_str(), bestMessage);
+        } else if (toStringResult) {
+            CopyUTF8toUTF16(toStringResult, bestMessage);
+        } else {
+            bestMessage.AssignLiteral("JavaScript Error");
+        }
+
+        const char16_t* linebuf = report->linebuf();
+
+        data = new nsScriptError();
+        data->InitWithWindowID(
+            bestMessage,
+            NS_ConvertASCIItoUTF16(report->filename),
+            linebuf ? nsDependentString(linebuf, report->linebufLength()) : EmptyString(),
+            report->lineno,
+            report->tokenOffset(), report->flags,
+            NS_LITERAL_CSTRING("XPConnect JavaScript"),
+            nsJSUtils::GetCurrentlyRunningCodeInnerWindowID(cx));
+    }
+
+    if (data) {
+        nsAutoCString formattedMsg;
+        data->ToString(formattedMsg);
+
+        rv = XPCConvert::ConstructException(NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS,
+                                            formattedMsg.get(), ifaceName,
+                                            methodName,
+                                            static_cast<nsIScriptError*>(data.get()),
+                                            exceptn, nullptr, nullptr);
+    } else {
+        rv = XPCConvert::ConstructException(NS_ERROR_XPC_JAVASCRIPT_ERROR,
+                                            nullptr, ifaceName, methodName,
+                                            nullptr, exceptn, nullptr, nullptr);
+    }
+    return rv;
+}
+
+// static
+nsresult
+XPCConvert::JSValToXPCException(MutableHandleValue s,
+                                const char* ifaceName,
+                                const char* methodName,
+                                nsIException** exceptn)
+{
+    AutoJSContext cx;
+    AutoExceptionRestorer aer(cx, s);
+
+    if (!s.isPrimitive()) {
+        // we have a JSObject
+        RootedObject obj(cx, s.toObjectOrNull());
+
+        if (!obj) {
+            NS_ERROR("when is an object not an object?");
+            return NS_ERROR_FAILURE;
+        }
+
+        // is this really a native xpcom object with a wrapper?
+        JSObject* unwrapped = js::CheckedUnwrap(obj, /* stopAtWindowProxy = */ false);
+        if (!unwrapped)
+            return NS_ERROR_XPC_SECURITY_MANAGER_VETO;
+        if (nsCOMPtr<nsISupports> supports = UnwrapReflectorToISupports(unwrapped)) {
+            nsCOMPtr<nsIException> iface = do_QueryInterface(supports);
+            if (iface) {
+                // just pass through the exception (with extra ref and all)
+                nsCOMPtr<nsIException> temp = iface;
+                temp.forget(exceptn);
+                return NS_OK;
+            } else {
+                // it is a wrapped native, but not an exception!
+                return ConstructException(NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT,
+                                          nullptr, ifaceName, methodName, supports,
+                                          exceptn, nullptr, nullptr);
+            }
+        } else {
+            // It is a JSObject, but not a wrapped native...
+
+            // If it is an engine Error with an error report then let's
+            // extract the report and build an xpcexception from that
+            const JSErrorReport* report;
+            if (nullptr != (report = JS_ErrorFromException(cx, obj))) {
+                JSAutoByteString toStringResult;
+                RootedString str(cx, ToString(cx, s));
+                if (str)
+                    toStringResult.encodeUtf8(cx, str);
+                return JSErrorToXPCException(toStringResult.ptr(), ifaceName,
+                                             methodName, report, exceptn);
+            }
+
+            // XXX we should do a check against 'js_ErrorClass' here and
+            // do the right thing - even though it has no JSErrorReport,
+            // The fact that it is a JSError exceptions means we can extract
+            // particular info and our 'result' should reflect that.
+
+            // otherwise we'll just try to convert it to a string
+
+            JSString* str = ToString(cx, s);
+            if (!str)
+                return NS_ERROR_FAILURE;
+
+            JSAutoByteString strBytes(cx, str);
+            if (!strBytes)
+                return NS_ERROR_FAILURE;
+
+            return ConstructException(NS_ERROR_XPC_JS_THREW_JS_OBJECT,
+                                      strBytes.ptr(), ifaceName, methodName,
+                                      nullptr, exceptn, cx, s.address());
+        }
+    }
+
+    if (s.isUndefined() || s.isNull()) {
+        return ConstructException(NS_ERROR_XPC_JS_THREW_NULL,
+                                  nullptr, ifaceName, methodName, nullptr,
+                                  exceptn, cx, s.address());
+    }
+
+    if (s.isNumber()) {
+        // lets see if it looks like an nsresult
+        nsresult rv;
+        double number;
+        bool isResult = false;
+
+        if (s.isInt32()) {
+            rv = (nsresult) s.toInt32();
+            if (NS_FAILED(rv))
+                isResult = true;
+            else
+                number = (double) s.toInt32();
+        } else {
+            number = s.toDouble();
+            if (number > 0.0 &&
+                number < (double)0xffffffff &&
+                0.0 == fmod(number,1)) {
+                // Visual Studio 9 doesn't allow casting directly from a
+                // double to an enumeration type, contrary to 5.2.9(10) of
+                // C++11, so add an intermediate cast.
+                rv = (nsresult)(uint32_t) number;
+                if (NS_FAILED(rv))
+                    isResult = true;
+            }
+        }
+
+        if (isResult)
+            return ConstructException(rv, nullptr, ifaceName, methodName,
+                                      nullptr, exceptn, cx, s.address());
+        else {
+            // XXX all this nsISupportsDouble code seems a little redundant
+            // now that we're storing the Value in the exception...
+            nsCOMPtr<nsISupportsDouble> data;
+            nsCOMPtr<nsIComponentManager> cm;
+            if (NS_FAILED(NS_GetComponentManager(getter_AddRefs(cm))) || !cm ||
+                NS_FAILED(cm->CreateInstanceByContractID(NS_SUPPORTS_DOUBLE_CONTRACTID,
+                                                         nullptr,
+                                                         NS_GET_IID(nsISupportsDouble),
+                                                         getter_AddRefs(data))))
+                return NS_ERROR_FAILURE;
+            data->SetData(number);
+            rv = ConstructException(NS_ERROR_XPC_JS_THREW_NUMBER, nullptr,
+                                    ifaceName, methodName, data, exceptn, cx, s.address());
+            return rv;
+        }
+    }
+
+    // otherwise we'll just try to convert it to a string
+    // Note: e.g., bools get converted to JSStrings by this code.
+
+    JSString* str = ToString(cx, s);
+    if (str) {
+        JSAutoByteString strBytes(cx, str);
+        if (!!strBytes) {
+            return ConstructException(NS_ERROR_XPC_JS_THREW_STRING,
+                                      strBytes.ptr(), ifaceName, methodName,
+                                      nullptr, exceptn, cx, s.address());
+        }
+    }
+    return NS_ERROR_FAILURE;
+}
+
+/***************************************************************************/
+
+// array fun...
+
+#ifdef POPULATE
+#undef POPULATE
+#endif
+
+// static
+bool
+XPCConvert::NativeArray2JS(MutableHandleValue d, const void** s,
+                           const nsXPTType& type, const nsID* iid,
+                           uint32_t count, nsresult* pErr)
+{
+    NS_PRECONDITION(s, "bad param");
+
+    AutoJSContext cx;
+
+    // XXX add support for putting chars in a string rather than an array
+
+    // XXX add support to indicate *which* array element was not convertable
+
+    RootedObject array(cx, JS_NewArrayObject(cx, count));
+    if (!array)
+        return false;
+
+    if (pErr)
+        *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE;
+
+    uint32_t i;
+    RootedValue current(cx, JS::NullValue());
+
+#define POPULATE(_t)                                                                    \
+    PR_BEGIN_MACRO                                                                      \
+        for (i = 0; i < count; i++) {                                                   \
+            if (!NativeData2JS(&current, ((_t*)*s)+i, type, iid, pErr) ||               \
+                !JS_DefineElement(cx, array, i, current, JSPROP_ENUMERATE))             \
+                return false;                                                           \
+        }                                                                               \
+    PR_END_MACRO
+
+    // XXX check IsPtr - esp. to handle array of nsID (as opposed to nsID*)
+
+    switch (type.TagPart()) {
+    case nsXPTType::T_I8            : POPULATE(int8_t);         break;
+    case nsXPTType::T_I16           : POPULATE(int16_t);        break;
+    case nsXPTType::T_I32           : POPULATE(int32_t);        break;
+    case nsXPTType::T_I64           : POPULATE(int64_t);        break;
+    case nsXPTType::T_U8            : POPULATE(uint8_t);        break;
+    case nsXPTType::T_U16           : POPULATE(uint16_t);       break;
+    case nsXPTType::T_U32           : POPULATE(uint32_t);       break;
+    case nsXPTType::T_U64           : POPULATE(uint64_t);       break;
+    case nsXPTType::T_FLOAT         : POPULATE(float);          break;
+    case nsXPTType::T_DOUBLE        : POPULATE(double);         break;
+    case nsXPTType::T_BOOL          : POPULATE(bool);           break;
+    case nsXPTType::T_CHAR          : POPULATE(char);           break;
+    case nsXPTType::T_WCHAR         : POPULATE(char16_t);       break;
+    case nsXPTType::T_VOID          : NS_ERROR("bad type");     return false;
+    case nsXPTType::T_IID           : POPULATE(nsID*);          break;
+    case nsXPTType::T_DOMSTRING     : NS_ERROR("bad type");     return false;
+    case nsXPTType::T_CHAR_STR      : POPULATE(char*);          break;
+    case nsXPTType::T_WCHAR_STR     : POPULATE(char16_t*);      break;
+    case nsXPTType::T_INTERFACE     : POPULATE(nsISupports*);   break;
+    case nsXPTType::T_INTERFACE_IS  : POPULATE(nsISupports*);   break;
+    case nsXPTType::T_UTF8STRING    : NS_ERROR("bad type");     return false;
+    case nsXPTType::T_CSTRING       : NS_ERROR("bad type");     return false;
+    case nsXPTType::T_ASTRING       : NS_ERROR("bad type");     return false;
+    default                         : NS_ERROR("bad type");     return false;
+    }
+
+    if (pErr)
+        *pErr = NS_OK;
+    d.setObject(*array);
+    return true;
+
+#undef POPULATE
+}
+
+
+
+// Check that the tag part of the type matches the type
+// of the array. If the check succeeds, check that the size
+// of the output does not exceed UINT32_MAX bytes. Allocate
+// the memory and copy the elements by memcpy.
+static bool
+CheckTargetAndPopulate(const nsXPTType& type,
+                       uint8_t requiredType,
+                       size_t typeSize,
+                       uint32_t count,
+                       JSObject* tArr,
+                       void** output,
+                       nsresult* pErr)
+{
+    // Check that the element type expected by the interface matches
+    // the type of the elements in the typed array exactly, including
+    // signedness.
+    if (type.TagPart() != requiredType) {
+        if (pErr)
+            *pErr = NS_ERROR_XPC_BAD_CONVERT_JS;
+
+        return false;
+    }
+
+    // Calulate the maximum number of elements that can fit in
+    // UINT32_MAX bytes.
+    size_t max = UINT32_MAX / typeSize;
+
+    // This could overflow on 32-bit systems so check max first.
+    size_t byteSize = count * typeSize;
+    if (count > max || !(*output = moz_xmalloc(byteSize))) {
+        if (pErr)
+            *pErr = NS_ERROR_OUT_OF_MEMORY;
+
+        return false;
+    }
+
+    JS::AutoCheckCannotGC nogc;
+    bool isShared;
+    void* buf = JS_GetArrayBufferViewData(tArr, &isShared, nogc);
+
+    // Require opting in to shared memory - a future project.
+    if (isShared) {
+        if (pErr)
+            *pErr = NS_ERROR_XPC_BAD_CONVERT_JS;
+
+        return false;
+    }
+
+    memcpy(*output, buf, byteSize);
+    return true;
+}
+
+// Fast conversion of typed arrays to native using memcpy.
+// No float or double canonicalization is done. Called by
+// JSarray2Native whenever a TypedArray is met. ArrayBuffers
+// are not accepted; create a properly typed array view on them
+// first. The element type of array must match the XPCOM
+// type in size, type and signedness exactly. As an exception,
+// Uint8ClampedArray is allowed for arrays of uint8_t. DataViews
+// are not supported.
+
+// static
+bool
+XPCConvert::JSTypedArray2Native(void** d,
+                                JSObject* jsArray,
+                                uint32_t count,
+                                const nsXPTType& type,
+                                nsresult* pErr)
+{
+    MOZ_ASSERT(jsArray, "bad param");
+    MOZ_ASSERT(d, "bad param");
+    MOZ_ASSERT(JS_IsTypedArrayObject(jsArray), "not a typed array");
+
+    // Check the actual length of the input array against the
+    // given size_is.
+    uint32_t len = JS_GetTypedArrayLength(jsArray);
+    if (len < count) {
+        if (pErr)
+            *pErr = NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY;
+
+        return false;
+    }
+
+    void* output = nullptr;
+
+    switch (JS_GetArrayBufferViewType(jsArray)) {
+    case js::Scalar::Int8:
+        if (!CheckTargetAndPopulate(nsXPTType::T_I8, type,
+                                    sizeof(int8_t), count,
+                                    jsArray, &output, pErr)) {
+            return false;
+        }
+        break;
+
+    case js::Scalar::Uint8:
+    case js::Scalar::Uint8Clamped:
+        if (!CheckTargetAndPopulate(nsXPTType::T_U8, type,
+                                    sizeof(uint8_t), count,
+                                    jsArray, &output, pErr)) {
+            return false;
+        }
+        break;
+
+    case js::Scalar::Int16:
+        if (!CheckTargetAndPopulate(nsXPTType::T_I16, type,
+                                    sizeof(int16_t), count,
+                                    jsArray, &output, pErr)) {
+            return false;
+        }
+        break;
+
+    case js::Scalar::Uint16:
+        if (!CheckTargetAndPopulate(nsXPTType::T_U16, type,
+                                    sizeof(uint16_t), count,
+                                    jsArray, &output, pErr)) {
+            return false;
+        }
+        break;
+
+    case js::Scalar::Int32:
+        if (!CheckTargetAndPopulate(nsXPTType::T_I32, type,
+                                    sizeof(int32_t), count,
+                                    jsArray, &output, pErr)) {
+            return false;
+        }
+        break;
+
+    case js::Scalar::Uint32:
+        if (!CheckTargetAndPopulate(nsXPTType::T_U32, type,
+                                    sizeof(uint32_t), count,
+                                    jsArray, &output, pErr)) {
+            return false;
+        }
+        break;
+
+    case js::Scalar::Float32:
+        if (!CheckTargetAndPopulate(nsXPTType::T_FLOAT, type,
+                                    sizeof(float), count,
+                                    jsArray, &output, pErr)) {
+            return false;
+        }
+        break;
+
+    case js::Scalar::Float64:
+        if (!CheckTargetAndPopulate(nsXPTType::T_DOUBLE, type,
+                                    sizeof(double), count,
+                                    jsArray, &output, pErr)) {
+            return false;
+        }
+        break;
+
+    // Yet another array type was defined? It is not supported yet...
+    default:
+        if (pErr)
+            *pErr = NS_ERROR_XPC_BAD_CONVERT_JS;
+
+        return false;
+    }
+
+    *d = output;
+    if (pErr)
+        *pErr = NS_OK;
+
+    return true;
+}
+
+// static
+bool
+XPCConvert::JSArray2Native(void** d, HandleValue s,
+                           uint32_t count, const nsXPTType& type,
+                           const nsID* iid, nsresult* pErr)
+{
+    MOZ_ASSERT(d, "bad param");
+
+    AutoJSContext cx;
+
+    // XXX add support for getting chars from strings
+
+    // XXX add support to indicate *which* array element was not convertable
+
+    if (s.isNullOrUndefined()) {
+        if (0 != count) {
+            if (pErr)
+                *pErr = NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY;
+            return false;
+        }
+
+        *d = nullptr;
+        return true;
+    }
+
+    if (!s.isObject()) {
+        if (pErr)
+            *pErr = NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY;
+        return false;
+    }
+
+    RootedObject jsarray(cx, &s.toObject());
+
+    // If this is a typed array, then try a fast conversion with memcpy.
+    if (JS_IsTypedArrayObject(jsarray)) {
+        return JSTypedArray2Native(d, jsarray, count, type, pErr);
+    }
+
+    bool isArray;
+    if (!JS_IsArrayObject(cx, jsarray, &isArray) || !isArray) {
+        if (pErr)
+            *pErr = NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY;
+        return false;
+    }
+
+    uint32_t len;
+    if (!JS_GetArrayLength(cx, jsarray, &len) || len < count) {
+        if (pErr)
+            *pErr = NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY;
+        return false;
+    }
+
+    if (pErr)
+        *pErr = NS_ERROR_XPC_BAD_CONVERT_JS;
+
+#define POPULATE(_mode, _t)                                                    \
+    PR_BEGIN_MACRO                                                             \
+        cleanupMode = _mode;                                                   \
+        size_t max = UINT32_MAX / sizeof(_t);                                  \
+        if (count > max ||                                                     \
+            nullptr == (array = moz_xmalloc(count * sizeof(_t)))) {            \
+            if (pErr)                                                          \
+                *pErr = NS_ERROR_OUT_OF_MEMORY;                                \
+            goto failure;                                                      \
+        }                                                                      \
+        for (initedCount = 0; initedCount < count; initedCount++) {            \
+            if (!JS_GetElement(cx, jsarray, initedCount, &current) ||          \
+                !JSData2Native(((_t*)array)+initedCount, current, type,        \
+                               iid, pErr))                                     \
+                goto failure;                                                  \
+        }                                                                      \
+    PR_END_MACRO
+
+    // No Action, FRee memory, RElease object
+    enum CleanupMode {na, fr, re};
+
+    CleanupMode cleanupMode;
+
+    void* array = nullptr;
+    uint32_t initedCount;
+    RootedValue current(cx);
+
+    // XXX check IsPtr - esp. to handle array of nsID (as opposed to nsID*)
+    // XXX make extra space at end of char* and wchar* and null termintate
+
+    switch (type.TagPart()) {
+    case nsXPTType::T_I8            : POPULATE(na, int8_t);         break;
+    case nsXPTType::T_I16           : POPULATE(na, int16_t);        break;
+    case nsXPTType::T_I32           : POPULATE(na, int32_t);        break;
+    case nsXPTType::T_I64           : POPULATE(na, int64_t);        break;
+    case nsXPTType::T_U8            : POPULATE(na, uint8_t);        break;
+    case nsXPTType::T_U16           : POPULATE(na, uint16_t);       break;
+    case nsXPTType::T_U32           : POPULATE(na, uint32_t);       break;
+    case nsXPTType::T_U64           : POPULATE(na, uint64_t);       break;
+    case nsXPTType::T_FLOAT         : POPULATE(na, float);          break;
+    case nsXPTType::T_DOUBLE        : POPULATE(na, double);         break;
+    case nsXPTType::T_BOOL          : POPULATE(na, bool);           break;
+    case nsXPTType::T_CHAR          : POPULATE(na, char);           break;
+    case nsXPTType::T_WCHAR         : POPULATE(na, char16_t);       break;
+    case nsXPTType::T_VOID          : NS_ERROR("bad type");         goto failure;
+    case nsXPTType::T_IID           : POPULATE(fr, nsID*);          break;
+    case nsXPTType::T_DOMSTRING     : NS_ERROR("bad type");         goto failure;
+    case nsXPTType::T_CHAR_STR      : POPULATE(fr, char*);          break;
+    case nsXPTType::T_WCHAR_STR     : POPULATE(fr, char16_t*);      break;
+    case nsXPTType::T_INTERFACE     : POPULATE(re, nsISupports*);   break;
+    case nsXPTType::T_INTERFACE_IS  : POPULATE(re, nsISupports*);   break;
+    case nsXPTType::T_UTF8STRING    : NS_ERROR("bad type");         goto failure;
+    case nsXPTType::T_CSTRING       : NS_ERROR("bad type");         goto failure;
+    case nsXPTType::T_ASTRING       : NS_ERROR("bad type");         goto failure;
+    default                         : NS_ERROR("bad type");         goto failure;
+    }
+
+    *d = array;
+    if (pErr)
+        *pErr = NS_OK;
+    return true;
+
+failure:
+    // we may need to cleanup the partially filled array of converted stuff
+    if (array) {
+        if (cleanupMode == re) {
+            nsISupports** a = (nsISupports**) array;
+            for (uint32_t i = 0; i < initedCount; i++) {
+                nsISupports* p = a[i];
+                NS_IF_RELEASE(p);
+            }
+        } else if (cleanupMode == fr) {
+            void** a = (void**) array;
+            for (uint32_t i = 0; i < initedCount; i++) {
+                void* p = a[i];
+                if (p) free(p);
+            }
+        }
+        free(array);
+    }
+
+    return false;
+
+#undef POPULATE
+}
+
+// static
+bool
+XPCConvert::NativeStringWithSize2JS(MutableHandleValue d, const void* s,
+                                    const nsXPTType& type,
+                                    uint32_t count,
+                                    nsresult* pErr)
+{
+    NS_PRECONDITION(s, "bad param");
+
+    AutoJSContext cx;
+    if (pErr)
+        *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE;
+
+    switch (type.TagPart()) {
+        case nsXPTType::T_PSTRING_SIZE_IS:
+        {
+            char* p = *((char**)s);
+            if (!p)
+                break;
+            JSString* str;
+            if (!(str = JS_NewStringCopyN(cx, p, count)))
+                return false;
+            d.setString(str);
+            break;
+        }
+        case nsXPTType::T_PWSTRING_SIZE_IS:
+        {
+            char16_t* p = *((char16_t**)s);
+            if (!p)
+                break;
+            JSString* str;
+            if (!(str = JS_NewUCStringCopyN(cx, p, count)))
+                return false;
+            d.setString(str);
+            break;
+        }
+        default:
+            XPC_LOG_ERROR(("XPCConvert::NativeStringWithSize2JS : unsupported type"));
+            return false;
+    }
+    return true;
+}
+
+// static
+bool
+XPCConvert::JSStringWithSize2Native(void* d, HandleValue s,
+                                    uint32_t count, const nsXPTType& type,
+                                    nsresult* pErr)
+{
+    NS_PRECONDITION(!s.isNull(), "bad param");
+    NS_PRECONDITION(d, "bad param");
+
+    AutoJSContext cx;
+    uint32_t len;
+
+    if (pErr)
+        *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE;
+
+    switch (type.TagPart()) {
+        case nsXPTType::T_PSTRING_SIZE_IS:
+        {
+            if (s.isUndefined() || s.isNull()) {
+                if (0 != count) {
+                    if (pErr)
+                        *pErr = NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING;
+                    return false;
+                }
+                if (0 != count) {
+                    len = (count + 1) * sizeof(char);
+                    if (!(*((void**)d) = moz_xmalloc(len)))
+                        return false;
+                    return true;
+                }
+                // else ...
+
+                *((char**)d) = nullptr;
+                return true;
+            }
+
+            JSString* str = ToString(cx, s);
+            if (!str) {
+                return false;
+            }
+
+            size_t length = JS_GetStringEncodingLength(cx, str);
+            if (length == size_t(-1)) {
+                return false;
+            }
+            if (length > count) {
+                if (pErr)
+                    *pErr = NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING;
+                return false;
+            }
+            len = uint32_t(length);
+
+            if (len < count)
+                len = count;
+
+            uint32_t alloc_len = (len + 1) * sizeof(char);
+            char* buffer = static_cast<char*>(moz_xmalloc(alloc_len));
+            if (!buffer) {
+                return false;
+            }
+            JS_EncodeStringToBuffer(cx, str, buffer, len);
+            buffer[len] = '\0';
+            *((char**)d) = buffer;
+
+            return true;
+        }
+
+        case nsXPTType::T_PWSTRING_SIZE_IS:
+        {
+            JSString* str;
+
+            if (s.isUndefined() || s.isNull()) {
+                if (0 != count) {
+                    if (pErr)
+                        *pErr = NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING;
+                    return false;
+                }
+
+                if (0 != count) {
+                    len = (count + 1) * sizeof(char16_t);
+                    if (!(*((void**)d) = moz_xmalloc(len)))
+                        return false;
+                    return true;
+                }
+
+                // else ...
+                *((const char16_t**)d) = nullptr;
+                return true;
+            }
+
+            if (!(str = ToString(cx, s))) {
+                return false;
+            }
+
+            len = JS_GetStringLength(str);
+            if (len > count) {
+                if (pErr)
+                    *pErr = NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING;
+                return false;
+            }
+
+            len = count;
+
+            uint32_t alloc_len = (len + 1) * sizeof(char16_t);
+            if (!(*((void**)d) = moz_xmalloc(alloc_len))) {
+                // XXX should report error
+                return false;
+            }
+            mozilla::Range<char16_t> destChars(*((char16_t**)d), len + 1);
+            if (!JS_CopyStringChars(cx, destChars, str))
+                return false;
+            destChars[count] = 0;
+
+            return true;
+        }
+        default:
+            XPC_LOG_ERROR(("XPCConvert::JSStringWithSize2Native : unsupported type"));
+            return false;
+    }
+}
diff --git a/js/xpconnect/src/XPCDebug.cpp b/js/xpconnect/src/XPCDebug.cpp
new file mode 100644
index 000000000..f8500ba10
--- /dev/null
+++ b/js/xpconnect/src/XPCDebug.cpp
@@ -0,0 +1,63 @@
+/* -*- 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 "xpcprivate.h"
+#include "jsprf.h"
+#include "nsThreadUtils.h"
+#include "nsContentUtils.h"
+
+#include "mozilla/Sprintf.h"
+
+#ifdef XP_WIN
+#include <windows.h>
+#endif
+
+static void DebugDump(const char* fmt, ...)
+{
+  char buffer[2048];
+  va_list ap;
+  va_start(ap, fmt);
+#ifdef XPWIN
+  _vsnprintf(buffer, sizeof(buffer), fmt, ap);
+  buffer[sizeof(buffer)-1] = '\0';
+#else
+  VsprintfLiteral(buffer, fmt, ap);
+#endif
+  va_end(ap);
+#ifdef XP_WIN
+  if (IsDebuggerPresent()) {
+    OutputDebugStringA(buffer);
+  }
+#endif
+  printf("%s", buffer);
+}
+
+bool
+xpc_DumpJSStack(bool showArgs, bool showLocals, bool showThisProps)
+{
+    JSContext* cx = nsContentUtils::GetCurrentJSContextForThread();
+    if (!cx) {
+        printf("there is no JSContext on the stack!\n");
+    } else if (char* buf = xpc_PrintJSStack(cx, showArgs, showLocals, showThisProps)) {
+        DebugDump("%s\n", buf);
+        JS_smprintf_free(buf);
+    }
+    return true;
+}
+
+char*
+xpc_PrintJSStack(JSContext* cx, bool showArgs, bool showLocals,
+                 bool showThisProps)
+{
+    JS::AutoSaveExceptionState state(cx);
+
+    char* buf = JS::FormatStackDump(cx, nullptr, showArgs, showLocals, showThisProps);
+    if (!buf)
+        DebugDump("%s", "Failed to format JavaScript stack for dump\n");
+
+    state.restore();
+    return buf;
+}
diff --git a/js/xpconnect/src/XPCException.cpp b/js/xpconnect/src/XPCException.cpp
new file mode 100644
index 000000000..575cc4aa3
--- /dev/null
+++ b/js/xpconnect/src/XPCException.cpp
@@ -0,0 +1,80 @@
+/* -*- 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/. */
+
+/* An implementaion of nsIException. */
+
+#include "xpcprivate.h"
+#include "nsError.h"
+
+/***************************************************************************/
+/* Quick and dirty mapping of well known result codes to strings. We only
+*  call this when building an exception object, so iterating the short array
+*  is not too bad.
+*
+*  It sure would be nice to have exceptions declared in idl and available
+*  in some more global way at runtime.
+*/
+
+static const struct ResultMap
+{nsresult rv; const char* name; const char* format;} map[] = {
+#define XPC_MSG_DEF(val, format) \
+    {(val), #val, format},
+#include "xpc.msg"
+#undef XPC_MSG_DEF
+    {NS_OK,0,0}   // sentinel to mark end of array
+};
+
+#define RESULT_COUNT ((sizeof(map) / sizeof(map[0]))-1)
+
+// static
+bool
+nsXPCException::NameAndFormatForNSResult(nsresult rv,
+                                         const char** name,
+                                         const char** format)
+{
+
+    for (const ResultMap* p = map; p->name; p++) {
+        if (rv == p->rv) {
+            if (name) *name = p->name;
+            if (format) *format = p->format;
+            return true;
+        }
+    }
+    return false;
+}
+
+// static
+const void*
+nsXPCException::IterateNSResults(nsresult* rv,
+                                 const char** name,
+                                 const char** format,
+                                 const void** iterp)
+{
+    const ResultMap* p = (const ResultMap*) *iterp;
+    if (!p)
+        p = map;
+    else
+        p++;
+    if (!p->name)
+        p = nullptr;
+    else {
+        if (rv)
+            *rv = p->rv;
+        if (name)
+            *name = p->name;
+        if (format)
+            *format = p->format;
+    }
+    *iterp = p;
+    return p;
+}
+
+// static
+uint32_t
+nsXPCException::GetNSResultCount()
+{
+    return RESULT_COUNT;
+}
diff --git a/js/xpconnect/src/XPCForwards.h b/js/xpconnect/src/XPCForwards.h
new file mode 100644
index 000000000..c1259bb3a
--- /dev/null
+++ b/js/xpconnect/src/XPCForwards.h
@@ -0,0 +1,64 @@
+/* -*- 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/. */
+
+/* Private forward declarations. */
+
+#ifndef xpcforwards_h___
+#define xpcforwards_h___
+
+// forward declarations of interally used classes...
+
+class nsXPConnect;
+class XPCJSContext;
+class XPCContext;
+class XPCCallContext;
+
+class XPCJSThrower;
+
+class nsXPCWrappedJS;
+class nsXPCWrappedJSClass;
+
+class XPCNativeMember;
+class XPCNativeInterface;
+class XPCNativeSet;
+
+class XPCWrappedNative;
+class XPCWrappedNativeProto;
+class XPCWrappedNativeTearOff;
+class XPCNativeScriptableInfo;
+class XPCNativeScriptableCreateInfo;
+
+class XPCTraceableVariant;
+class XPCJSObjectHolder;
+
+class JSObject2WrappedJSMap;
+class Native2WrappedNativeMap;
+class IID2WrappedJSClassMap;
+class IID2NativeInterfaceMap;
+class ClassInfo2NativeSetMap;
+class ClassInfo2WrappedNativeProtoMap;
+class NativeSetMap;
+class IID2ThisTranslatorMap;
+class XPCWrappedNativeProtoMap;
+class JSObject2JSObjectMap;
+
+class nsXPCComponents;
+class nsXPCComponents_Interfaces;
+class nsXPCComponents_InterfacesByID;
+class nsXPCComponents_Classes;
+class nsXPCComponents_ClassesByID;
+class nsXPCComponents_Results;
+class nsXPCComponents_ID;
+class nsXPCComponents_Exception;
+class nsXPCComponents_Constructor;
+class nsXPCComponents_Utils;
+class nsXPCConstructor;
+
+class AutoMarkingPtr;
+
+class xpcProperty;
+
+#endif /* xpcforwards_h___ */
diff --git a/js/xpconnect/src/XPCInlines.h b/js/xpconnect/src/XPCInlines.h
new file mode 100644
index 000000000..20c63c972
--- /dev/null
+++ b/js/xpconnect/src/XPCInlines.h
@@ -0,0 +1,545 @@
+/* -*- 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/. */
+
+/* private inline methods (#include'd by xpcprivate.h). */
+
+#ifndef xpcinlines_h___
+#define xpcinlines_h___
+
+#include <algorithm>
+
+/***************************************************************************/
+
+inline void
+XPCJSContext::AddVariantRoot(XPCTraceableVariant* variant)
+{
+    variant->AddToRootSet(&mVariantRoots);
+}
+
+inline void
+XPCJSContext::AddWrappedJSRoot(nsXPCWrappedJS* wrappedJS)
+{
+    wrappedJS->AddToRootSet(&mWrappedJSRoots);
+}
+
+inline void
+XPCJSContext::AddObjectHolderRoot(XPCJSObjectHolder* holder)
+{
+    holder->AddToRootSet(&mObjectHolderRoots);
+}
+
+/***************************************************************************/
+
+inline bool
+XPCCallContext::IsValid() const
+{
+    return mState != INIT_FAILED;
+}
+
+inline XPCJSContext*
+XPCCallContext::GetContext() const
+{
+    CHECK_STATE(HAVE_CONTEXT);
+    return mXPCJSContext;
+}
+
+inline JSContext*
+XPCCallContext::GetJSContext() const
+{
+    CHECK_STATE(HAVE_CONTEXT);
+    return mJSContext;
+}
+
+inline XPCCallContext*
+XPCCallContext::GetPrevCallContext() const
+{
+    CHECK_STATE(HAVE_CONTEXT);
+    return mPrevCallContext;
+}
+
+inline nsISupports*
+XPCCallContext::GetIdentityObject() const
+{
+    CHECK_STATE(HAVE_OBJECT);
+    if (mWrapper)
+        return mWrapper->GetIdentityObject();
+    return nullptr;
+}
+
+inline XPCWrappedNative*
+XPCCallContext::GetWrapper() const
+{
+    if (mState == INIT_FAILED)
+        return nullptr;
+
+    CHECK_STATE(HAVE_OBJECT);
+    return mWrapper;
+}
+
+inline XPCWrappedNativeProto*
+XPCCallContext::GetProto() const
+{
+    CHECK_STATE(HAVE_OBJECT);
+    return mWrapper ? mWrapper->GetProto() : nullptr;
+}
+
+inline bool
+XPCCallContext::CanGetTearOff() const
+{
+    return mState >= HAVE_OBJECT;
+}
+
+inline XPCWrappedNativeTearOff*
+XPCCallContext::GetTearOff() const
+{
+    CHECK_STATE(HAVE_OBJECT);
+    return mTearOff;
+}
+
+inline XPCNativeScriptableInfo*
+XPCCallContext::GetScriptableInfo() const
+{
+    CHECK_STATE(HAVE_OBJECT);
+    return mScriptableInfo;
+}
+
+inline bool
+XPCCallContext::CanGetSet() const
+{
+    return mState >= HAVE_NAME;
+}
+
+inline XPCNativeSet*
+XPCCallContext::GetSet() const
+{
+    CHECK_STATE(HAVE_NAME);
+    return mSet;
+}
+
+inline XPCNativeInterface*
+XPCCallContext::GetInterface() const
+{
+    CHECK_STATE(HAVE_NAME);
+    return mInterface;
+}
+
+inline XPCNativeMember*
+XPCCallContext::GetMember() const
+{
+    CHECK_STATE(HAVE_NAME);
+    return mMember;
+}
+
+inline bool
+XPCCallContext::HasInterfaceAndMember() const
+{
+    return mState >= HAVE_NAME && mInterface && mMember;
+}
+
+inline jsid
+XPCCallContext::GetName() const
+{
+    CHECK_STATE(HAVE_NAME);
+    return mName;
+}
+
+inline bool
+XPCCallContext::GetStaticMemberIsLocal() const
+{
+    CHECK_STATE(HAVE_NAME);
+    return mStaticMemberIsLocal;
+}
+
+inline unsigned
+XPCCallContext::GetArgc() const
+{
+    CHECK_STATE(READY_TO_CALL);
+    return mArgc;
+}
+
+inline JS::Value*
+XPCCallContext::GetArgv() const
+{
+    CHECK_STATE(READY_TO_CALL);
+    return mArgv;
+}
+
+inline JS::Value*
+XPCCallContext::GetRetVal() const
+{
+    CHECK_STATE(READY_TO_CALL);
+    return mRetVal;
+}
+
+inline void
+XPCCallContext::SetRetVal(const JS::Value& val)
+{
+    CHECK_STATE(HAVE_ARGS);
+    if (mRetVal)
+        *mRetVal = val;
+}
+
+inline jsid
+XPCCallContext::GetResolveName() const
+{
+    CHECK_STATE(HAVE_CONTEXT);
+    return XPCJSContext::Get()->GetResolveName();
+}
+
+inline jsid
+XPCCallContext::SetResolveName(JS::HandleId name)
+{
+    CHECK_STATE(HAVE_CONTEXT);
+    return XPCJSContext::Get()->SetResolveName(name);
+}
+
+inline XPCWrappedNative*
+XPCCallContext::GetResolvingWrapper() const
+{
+    CHECK_STATE(HAVE_OBJECT);
+    return XPCJSContext::Get()->GetResolvingWrapper();
+}
+
+inline XPCWrappedNative*
+XPCCallContext::SetResolvingWrapper(XPCWrappedNative* w)
+{
+    CHECK_STATE(HAVE_OBJECT);
+    return XPCJSContext::Get()->SetResolvingWrapper(w);
+}
+
+inline uint16_t
+XPCCallContext::GetMethodIndex() const
+{
+    CHECK_STATE(HAVE_OBJECT);
+    return mMethodIndex;
+}
+
+inline void
+XPCCallContext::SetMethodIndex(uint16_t index)
+{
+    CHECK_STATE(HAVE_OBJECT);
+    mMethodIndex = index;
+}
+
+/***************************************************************************/
+inline XPCNativeInterface*
+XPCNativeMember::GetInterface() const
+{
+    XPCNativeMember* arrayStart =
+        const_cast<XPCNativeMember*>(this - mIndexInInterface);
+    size_t arrayStartOffset = XPCNativeInterface::OffsetOfMembers();
+    char* xpcNativeInterfaceStart =
+        reinterpret_cast<char*>(arrayStart) - arrayStartOffset;
+    return reinterpret_cast<XPCNativeInterface*>(xpcNativeInterfaceStart);
+}
+
+/***************************************************************************/
+
+inline const nsIID*
+XPCNativeInterface::GetIID() const
+{
+    const nsIID* iid;
+    return NS_SUCCEEDED(mInfo->GetIIDShared(&iid)) ? iid : nullptr;
+}
+
+inline const char*
+XPCNativeInterface::GetNameString() const
+{
+    const char* name;
+    return NS_SUCCEEDED(mInfo->GetNameShared(&name)) ? name : nullptr;
+}
+
+inline XPCNativeMember*
+XPCNativeInterface::FindMember(jsid name) const
+{
+    const XPCNativeMember* member = mMembers;
+    for (int i = (int) mMemberCount; i > 0; i--, member++)
+        if (member->GetName() == name)
+            return const_cast<XPCNativeMember*>(member);
+    return nullptr;
+}
+
+inline bool
+XPCNativeInterface::HasAncestor(const nsIID* iid) const
+{
+    bool found = false;
+    mInfo->HasAncestor(iid, &found);
+    return found;
+}
+
+/* static */
+inline size_t
+XPCNativeInterface::OffsetOfMembers()
+{
+    return offsetof(XPCNativeInterface, mMembers);
+}
+
+/***************************************************************************/
+
+inline XPCNativeSetKey::XPCNativeSetKey(XPCNativeSet* baseSet,
+                                        XPCNativeInterface* addition)
+    : mBaseSet(baseSet)
+    , mAddition(addition)
+{
+    MOZ_ASSERT(mBaseSet);
+    MOZ_ASSERT(mAddition);
+    MOZ_ASSERT(!mBaseSet->HasInterface(mAddition));
+}
+
+/***************************************************************************/
+
+inline bool
+XPCNativeSet::FindMember(jsid name, XPCNativeMember** pMember,
+                         uint16_t* pInterfaceIndex) const
+{
+    XPCNativeInterface* const * iface;
+    int count = (int) mInterfaceCount;
+    int i;
+
+    // look for interface names first
+
+    for (i = 0, iface = mInterfaces; i < count; i++, iface++) {
+        if (name == (*iface)->GetName()) {
+            if (pMember)
+                *pMember = nullptr;
+            if (pInterfaceIndex)
+                *pInterfaceIndex = (uint16_t) i;
+            return true;
+        }
+    }
+
+    // look for method names
+    for (i = 0, iface = mInterfaces; i < count; i++, iface++) {
+        XPCNativeMember* member = (*iface)->FindMember(name);
+        if (member) {
+            if (pMember)
+                *pMember = member;
+            if (pInterfaceIndex)
+                *pInterfaceIndex = (uint16_t) i;
+            return true;
+        }
+    }
+    return false;
+}
+
+inline bool
+XPCNativeSet::FindMember(jsid name, XPCNativeMember** pMember,
+                         RefPtr<XPCNativeInterface>* pInterface) const
+{
+    uint16_t index;
+    if (!FindMember(name, pMember, &index))
+        return false;
+    *pInterface = mInterfaces[index];
+    return true;
+}
+
+inline bool
+XPCNativeSet::FindMember(JS::HandleId name,
+                         XPCNativeMember** pMember,
+                         RefPtr<XPCNativeInterface>* pInterface,
+                         XPCNativeSet* protoSet,
+                         bool* pIsLocal) const
+{
+    XPCNativeMember* Member;
+    RefPtr<XPCNativeInterface> Interface;
+    XPCNativeMember* protoMember;
+
+    if (!FindMember(name, &Member, &Interface))
+        return false;
+
+    *pMember = Member;
+
+    *pIsLocal =
+        !Member ||
+        !protoSet ||
+        (protoSet != this &&
+         !protoSet->MatchesSetUpToInterface(this, Interface) &&
+         (!protoSet->FindMember(name, &protoMember, (uint16_t*)nullptr) ||
+          protoMember != Member));
+
+    *pInterface = Interface.forget();
+
+    return true;
+}
+
+inline XPCNativeInterface*
+XPCNativeSet::FindNamedInterface(jsid name) const
+{
+    XPCNativeInterface* const * pp = mInterfaces;
+
+    for (int i = (int) mInterfaceCount; i > 0; i--, pp++) {
+        XPCNativeInterface* iface = *pp;
+
+        if (name == iface->GetName())
+            return iface;
+    }
+    return nullptr;
+}
+
+inline XPCNativeInterface*
+XPCNativeSet::FindInterfaceWithIID(const nsIID& iid) const
+{
+    XPCNativeInterface* const * pp = mInterfaces;
+
+    for (int i = (int) mInterfaceCount; i > 0; i--, pp++) {
+        XPCNativeInterface* iface = *pp;
+
+        if (iface->GetIID()->Equals(iid))
+            return iface;
+    }
+    return nullptr;
+}
+
+inline bool
+XPCNativeSet::HasInterface(XPCNativeInterface* aInterface) const
+{
+    XPCNativeInterface* const * pp = mInterfaces;
+
+    for (int i = (int) mInterfaceCount; i > 0; i--, pp++) {
+        if (aInterface == *pp)
+            return true;
+    }
+    return false;
+}
+
+inline bool
+XPCNativeSet::HasInterfaceWithAncestor(XPCNativeInterface* aInterface) const
+{
+    return HasInterfaceWithAncestor(aInterface->GetIID());
+}
+
+inline bool
+XPCNativeSet::HasInterfaceWithAncestor(const nsIID* iid) const
+{
+    // We can safely skip the first interface which is *always* nsISupports.
+    XPCNativeInterface* const * pp = mInterfaces+1;
+    for (int i = (int) mInterfaceCount; i > 1; i--, pp++)
+        if ((*pp)->HasAncestor(iid))
+            return true;
+
+    // This is rare, so check last.
+    if (iid == &NS_GET_IID(nsISupports))
+        return true;
+
+    return false;
+}
+
+inline bool
+XPCNativeSet::MatchesSetUpToInterface(const XPCNativeSet* other,
+                                      XPCNativeInterface* iface) const
+{
+    int count = std::min(int(mInterfaceCount), int(other->mInterfaceCount));
+
+    XPCNativeInterface* const * pp1 = mInterfaces;
+    XPCNativeInterface* const * pp2 = other->mInterfaces;
+
+    for (int i = (int) count; i > 0; i--, pp1++, pp2++) {
+        XPCNativeInterface* cur = (*pp1);
+        if (cur != (*pp2))
+            return false;
+        if (cur == iface)
+            return true;
+    }
+    return false;
+}
+
+/***************************************************************************/
+
+inline
+JSObject* XPCWrappedNativeTearOff::GetJSObjectPreserveColor() const
+{
+    return mJSObject.unbarrieredGetPtr();
+}
+
+inline
+JSObject* XPCWrappedNativeTearOff::GetJSObject()
+{
+    return mJSObject;
+}
+
+inline
+void XPCWrappedNativeTearOff::SetJSObject(JSObject*  JSObj)
+{
+    MOZ_ASSERT(!IsMarked());
+    mJSObject = JSObj;
+}
+
+inline
+void XPCWrappedNativeTearOff::JSObjectMoved(JSObject* obj, const JSObject* old)
+{
+    MOZ_ASSERT(!IsMarked());
+    MOZ_ASSERT(mJSObject.unbarrieredGetPtr() == old);
+    mJSObject = obj;
+}
+
+inline
+XPCWrappedNativeTearOff::~XPCWrappedNativeTearOff()
+{
+    MOZ_COUNT_DTOR(XPCWrappedNativeTearOff);
+    MOZ_ASSERT(!(GetInterface() || GetNative() || GetJSObjectPreserveColor()),
+               "tearoff not empty in dtor");
+}
+
+/***************************************************************************/
+
+inline bool
+XPCWrappedNative::HasInterfaceNoQI(const nsIID& iid)
+{
+    return nullptr != GetSet()->FindInterfaceWithIID(iid);
+}
+
+inline void
+XPCWrappedNative::SweepTearOffs()
+{
+    for (XPCWrappedNativeTearOff* to = &mFirstTearOff; to; to = to->GetNextTearOff()) {
+        bool marked = to->IsMarked();
+        to->Unmark();
+        if (marked)
+            continue;
+
+        // If this tearoff does not have a live dedicated JSObject,
+        // then let's recycle it.
+        if (!to->GetJSObjectPreserveColor()) {
+            to->SetNative(nullptr);
+            to->SetInterface(nullptr);
+        }
+    }
+}
+
+/***************************************************************************/
+
+inline bool
+xpc_ForcePropertyResolve(JSContext* cx, JS::HandleObject obj, jsid idArg)
+{
+    JS::RootedId id(cx, idArg);
+    bool dummy;
+    return JS_HasPropertyById(cx, obj, id, &dummy);
+}
+
+inline jsid
+GetJSIDByIndex(JSContext* cx, unsigned index)
+{
+  XPCJSContext* xpcx = nsXPConnect::XPConnect()->GetContext();
+  return xpcx->GetStringID(index);
+}
+
+inline
+bool ThrowBadParam(nsresult rv, unsigned paramNum, XPCCallContext& ccx)
+{
+    XPCThrower::ThrowBadParam(rv, paramNum, ccx);
+    return false;
+}
+
+inline
+void ThrowBadResult(nsresult result, XPCCallContext& ccx)
+{
+    XPCThrower::ThrowBadResult(NS_ERROR_XPC_NATIVE_RETURNED_FAILURE,
+                               result, ccx);
+}
+
+/***************************************************************************/
+
+#endif /* xpcinlines_h___ */
diff --git a/js/xpconnect/src/XPCJSContext.cpp b/js/xpconnect/src/XPCJSContext.cpp
new file mode 100644
index 000000000..6981b525c
--- /dev/null
+++ b/js/xpconnect/src/XPCJSContext.cpp
@@ -0,0 +1,3771 @@
+/* -*- 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/. */
+
+/* Per JSContext object */
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/UniquePtr.h"
+
+#include "xpcprivate.h"
+#include "xpcpublic.h"
+#include "XPCWrapper.h"
+#include "XPCJSMemoryReporter.h"
+#include "WrapperFactory.h"
+#include "mozJSComponentLoader.h"
+#include "nsAutoPtr.h"
+#include "nsNetUtil.h"
+
+#include "nsIMemoryInfoDumper.h"
+#include "nsIMemoryReporter.h"
+#include "nsIObserverService.h"
+#include "nsIDebug2.h"
+#include "nsIDocShell.h"
+#include "nsIRunnable.h"
+#include "amIAddonManager.h"
+#include "nsPIDOMWindow.h"
+#include "nsPrintfCString.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/Services.h"
+#include "mozilla/dom/ScriptSettings.h"
+
+#include "nsContentUtils.h"
+#include "nsCCUncollectableMarker.h"
+#include "nsCycleCollectionNoteRootCallback.h"
+#include "nsCycleCollector.h"
+#include "nsScriptLoader.h"
+#include "jsapi.h"
+#include "jsprf.h"
+#include "js/MemoryMetrics.h"
+#include "mozilla/dom/GeneratedAtomList.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/WindowBinding.h"
+#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/ProcessHangMonitor.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/Unused.h"
+#include "AccessCheck.h"
+#include "nsGlobalWindow.h"
+#include "nsAboutProtocolUtils.h"
+
+#include "GeckoProfiler.h"
+#include "nsIXULRuntime.h"
+#include "nsJSPrincipals.h"
+
+#ifdef MOZ_CRASHREPORTER
+#include "nsExceptionHandler.h"
+#endif
+
+#if defined(MOZ_JEMALLOC4)
+#include "mozmemory.h"
+#endif
+
+#ifdef XP_WIN
+#include <windows.h>
+#endif
+
+using namespace mozilla;
+using namespace xpc;
+using namespace JS;
+using mozilla::dom::PerThreadAtomCache;
+using mozilla::dom::AutoEntryScript;
+
+/***************************************************************************/
+
+const char* const XPCJSContext::mStrings[] = {
+    "constructor",          // IDX_CONSTRUCTOR
+    "toString",             // IDX_TO_STRING
+    "toSource",             // IDX_TO_SOURCE
+    "lastResult",           // IDX_LAST_RESULT
+    "returnCode",           // IDX_RETURN_CODE
+    "value",                // IDX_VALUE
+    "QueryInterface",       // IDX_QUERY_INTERFACE
+    "Components",           // IDX_COMPONENTS
+    "wrappedJSObject",      // IDX_WRAPPED_JSOBJECT
+    "Object",               // IDX_OBJECT
+    "Function",             // IDX_FUNCTION
+    "prototype",            // IDX_PROTOTYPE
+    "createInstance",       // IDX_CREATE_INSTANCE
+    "item",                 // IDX_ITEM
+    "__proto__",            // IDX_PROTO
+    "__iterator__",         // IDX_ITERATOR
+    "__exposedProps__",     // IDX_EXPOSEDPROPS
+    "eval",                 // IDX_EVAL
+    "controllers",          // IDX_CONTROLLERS
+    "realFrameElement",     // IDX_REALFRAMEELEMENT
+    "length",               // IDX_LENGTH
+    "name",                 // IDX_NAME
+    "undefined",            // IDX_UNDEFINED
+    "",                     // IDX_EMPTYSTRING
+    "fileName",             // IDX_FILENAME
+    "lineNumber",           // IDX_LINENUMBER
+    "columnNumber",         // IDX_COLUMNNUMBER
+    "stack",                // IDX_STACK
+    "message",              // IDX_MESSAGE
+    "lastIndex"             // IDX_LASTINDEX
+};
+
+/***************************************************************************/
+
+static mozilla::Atomic<bool> sDiscardSystemSource(false);
+
+bool
+xpc::ShouldDiscardSystemSource() { return sDiscardSystemSource; }
+
+#ifdef DEBUG
+static mozilla::Atomic<bool> sExtraWarningsForSystemJS(false);
+bool xpc::ExtraWarningsForSystemJS() { return sExtraWarningsForSystemJS; }
+#else
+bool xpc::ExtraWarningsForSystemJS() { return false; }
+#endif
+
+static mozilla::Atomic<bool> sSharedMemoryEnabled(false);
+
+bool
+xpc::SharedMemoryEnabled() { return sSharedMemoryEnabled; }
+
+// *Some* NativeSets are referenced from mClassInfo2NativeSetMap.
+// *All* NativeSets are referenced from mNativeSetMap.
+// So, in mClassInfo2NativeSetMap we just clear references to the unmarked.
+// In mNativeSetMap we clear the references to the unmarked *and* delete them.
+
+class AsyncFreeSnowWhite : public Runnable
+{
+public:
+  NS_IMETHOD Run() override
+  {
+      TimeStamp start = TimeStamp::Now();
+      bool hadSnowWhiteObjects = nsCycleCollector_doDeferredDeletion();
+      Telemetry::Accumulate(Telemetry::CYCLE_COLLECTOR_ASYNC_SNOW_WHITE_FREEING,
+                            uint32_t((TimeStamp::Now() - start).ToMilliseconds()));
+      if (hadSnowWhiteObjects && !mContinuation) {
+          mContinuation = true;
+          if (NS_FAILED(NS_DispatchToCurrentThread(this))) {
+              mActive = false;
+          }
+      } else {
+#if defined(MOZ_JEMALLOC4)
+          if (mPurge) {
+              /* Jemalloc purges dirty pages regularly during free() when the
+               * ratio of dirty pages compared to active pages is higher than
+               * 1 << lg_dirty_mult. A high ratio can have an impact on
+               * performance, so we use the default ratio of 8, but force a
+               * regular purge of all remaining dirty pages, after cycle
+               * collection. */
+              Telemetry::AutoTimer<Telemetry::MEMORY_FREE_PURGED_PAGES_MS> timer;
+              jemalloc_free_dirty_pages();
+          }
+#endif
+          mActive = false;
+      }
+      return NS_OK;
+  }
+
+  void Dispatch(bool aContinuation = false, bool aPurge = false)
+  {
+      if (mContinuation) {
+          mContinuation = aContinuation;
+      }
+      mPurge = aPurge;
+      if (!mActive && NS_SUCCEEDED(NS_DispatchToCurrentThread(this))) {
+          mActive = true;
+      }
+  }
+
+  AsyncFreeSnowWhite() : mContinuation(false), mActive(false), mPurge(false) {}
+
+public:
+  bool mContinuation;
+  bool mActive;
+  bool mPurge;
+};
+
+namespace xpc {
+
+CompartmentPrivate::CompartmentPrivate(JSCompartment* c)
+    : wantXrays(false)
+    , allowWaivers(true)
+    , writeToGlobalPrototype(false)
+    , skipWriteToGlobalPrototype(false)
+    , isWebExtensionContentScript(false)
+    , waiveInterposition(false)
+    , allowCPOWs(false)
+    , universalXPConnectEnabled(false)
+    , forcePermissiveCOWs(false)
+    , scriptability(c)
+    , scope(nullptr)
+    , mWrappedJSMap(JSObject2WrappedJSMap::newMap(XPC_JS_MAP_LENGTH))
+{
+    MOZ_COUNT_CTOR(xpc::CompartmentPrivate);
+    mozilla::PodArrayZero(wrapperDenialWarnings);
+}
+
+CompartmentPrivate::~CompartmentPrivate()
+{
+    MOZ_COUNT_DTOR(xpc::CompartmentPrivate);
+    mWrappedJSMap->ShutdownMarker();
+    delete mWrappedJSMap;
+}
+
+static bool
+TryParseLocationURICandidate(const nsACString& uristr,
+                             CompartmentPrivate::LocationHint aLocationHint,
+                             nsIURI** aURI)
+{
+    static NS_NAMED_LITERAL_CSTRING(kGRE, "resource://gre/");
+    static NS_NAMED_LITERAL_CSTRING(kToolkit, "chrome://global/");
+    static NS_NAMED_LITERAL_CSTRING(kBrowser, "chrome://browser/");
+
+    if (aLocationHint == CompartmentPrivate::LocationHintAddon) {
+        // Blacklist some known locations which are clearly not add-on related.
+        if (StringBeginsWith(uristr, kGRE) ||
+            StringBeginsWith(uristr, kToolkit) ||
+            StringBeginsWith(uristr, kBrowser))
+            return false;
+
+        // -- GROSS HACK ALERT --
+        // The Yandex Elements 8.10.2 extension implements its own "xb://" URL
+        // scheme. If we call NS_NewURI() on an "xb://..." URL, we'll end up
+        // calling into the extension's own JS-implemented nsIProtocolHandler
+        // object, which we can't allow while we're iterating over the JS heap.
+        // So just skip any such URL.
+        // -- GROSS HACK ALERT --
+        if (StringBeginsWith(uristr, NS_LITERAL_CSTRING("xb")))
+            return false;
+    }
+
+    nsCOMPtr<nsIURI> uri;
+    if (NS_FAILED(NS_NewURI(getter_AddRefs(uri), uristr)))
+        return false;
+
+    nsAutoCString scheme;
+    if (NS_FAILED(uri->GetScheme(scheme)))
+        return false;
+
+    // Cannot really map data: and blob:.
+    // Also, data: URIs are pretty memory hungry, which is kinda bad
+    // for memory reporter use.
+    if (scheme.EqualsLiteral("data") || scheme.EqualsLiteral("blob"))
+        return false;
+
+    uri.forget(aURI);
+    return true;
+}
+
+bool CompartmentPrivate::TryParseLocationURI(CompartmentPrivate::LocationHint aLocationHint,
+                                             nsIURI** aURI)
+{
+    if (!aURI)
+        return false;
+
+    // Need to parse the URI.
+    if (location.IsEmpty())
+        return false;
+
+    // Handle Sandbox location strings.
+    // A sandbox string looks like this:
+    // <sandboxName> (from: <js-stack-frame-filename>:<lineno>)
+    // where <sandboxName> is user-provided via Cu.Sandbox()
+    // and <js-stack-frame-filename> and <lineno> is the stack frame location
+    // from where Cu.Sandbox was called.
+    // <js-stack-frame-filename> furthermore is "free form", often using a
+    // "uri -> uri -> ..." chain. The following code will and must handle this
+    // common case.
+    // It should be noted that other parts of the code may already rely on the
+    // "format" of these strings, such as the add-on SDK.
+
+    static const nsDependentCString from("(from: ");
+    static const nsDependentCString arrow(" -> ");
+    static const size_t fromLength = from.Length();
+    static const size_t arrowLength = arrow.Length();
+
+    // See: XPCComponents.cpp#AssembleSandboxMemoryReporterName
+    int32_t idx = location.Find(from);
+    if (idx < 0)
+        return TryParseLocationURICandidate(location, aLocationHint, aURI);
+
+
+    // When parsing we're looking for the right-most URI. This URI may be in
+    // <sandboxName>, so we try this first.
+    if (TryParseLocationURICandidate(Substring(location, 0, idx), aLocationHint,
+                                     aURI))
+        return true;
+
+    // Not in <sandboxName> so we need to inspect <js-stack-frame-filename> and
+    // the chain that is potentially contained within and grab the rightmost
+    // item that is actually a URI.
+
+    // First, hack off the :<lineno>) part as well
+    int32_t ridx = location.RFind(NS_LITERAL_CSTRING(":"));
+    nsAutoCString chain(Substring(location, idx + fromLength,
+                                  ridx - idx - fromLength));
+
+    // Loop over the "->" chain. This loop also works for non-chains, or more
+    // correctly chains with only one item.
+    for (;;) {
+        idx = chain.RFind(arrow);
+        if (idx < 0) {
+            // This is the last chain item. Try to parse what is left.
+            return TryParseLocationURICandidate(chain, aLocationHint, aURI);
+        }
+
+        // Try to parse current chain item
+        if (TryParseLocationURICandidate(Substring(chain, idx + arrowLength),
+                                         aLocationHint, aURI))
+            return true;
+
+        // Current chain item couldn't be parsed.
+        // Strip current item and continue.
+        chain = Substring(chain, 0, idx);
+    }
+
+    MOZ_CRASH("Chain parser loop does not terminate");
+}
+
+static bool
+PrincipalImmuneToScriptPolicy(nsIPrincipal* aPrincipal)
+{
+    // System principal gets a free pass.
+    if (nsXPConnect::SecurityManager()->IsSystemPrincipal(aPrincipal))
+        return true;
+
+    // nsExpandedPrincipal gets a free pass.
+    nsCOMPtr<nsIExpandedPrincipal> ep = do_QueryInterface(aPrincipal);
+    if (ep)
+        return true;
+
+    // Check whether our URI is an "about:" URI that allows scripts.  If it is,
+    // we need to allow JS to run.
+    nsCOMPtr<nsIURI> principalURI;
+    aPrincipal->GetURI(getter_AddRefs(principalURI));
+    MOZ_ASSERT(principalURI);
+    bool isAbout;
+    nsresult rv = principalURI->SchemeIs("about", &isAbout);
+    if (NS_SUCCEEDED(rv) && isAbout) {
+        nsCOMPtr<nsIAboutModule> module;
+        rv = NS_GetAboutModule(principalURI, getter_AddRefs(module));
+        if (NS_SUCCEEDED(rv)) {
+            uint32_t flags;
+            rv = module->GetURIFlags(principalURI, &flags);
+            if (NS_SUCCEEDED(rv) &&
+                (flags & nsIAboutModule::ALLOW_SCRIPT)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+Scriptability::Scriptability(JSCompartment* c) : mScriptBlocks(0)
+                                               , mDocShellAllowsScript(true)
+                                               , mScriptBlockedByPolicy(false)
+{
+    nsIPrincipal* prin = nsJSPrincipals::get(JS_GetCompartmentPrincipals(c));
+    mImmuneToScriptPolicy = PrincipalImmuneToScriptPolicy(prin);
+
+    // If we're not immune, we should have a real principal with a codebase URI.
+    // Check the URI against the new-style domain policy.
+    if (!mImmuneToScriptPolicy) {
+        nsCOMPtr<nsIURI> codebase;
+        nsresult rv = prin->GetURI(getter_AddRefs(codebase));
+        bool policyAllows;
+        if (NS_SUCCEEDED(rv) && codebase &&
+            NS_SUCCEEDED(nsXPConnect::SecurityManager()->PolicyAllowsScript(codebase, &policyAllows)))
+        {
+            mScriptBlockedByPolicy = !policyAllows;
+        } else {
+            // Something went wrong - be safe and block script.
+            mScriptBlockedByPolicy = true;
+        }
+    }
+}
+
+bool
+Scriptability::Allowed()
+{
+    return mDocShellAllowsScript && !mScriptBlockedByPolicy &&
+           mScriptBlocks == 0;
+}
+
+bool
+Scriptability::IsImmuneToScriptPolicy()
+{
+    return mImmuneToScriptPolicy;
+}
+
+void
+Scriptability::Block()
+{
+    ++mScriptBlocks;
+}
+
+void
+Scriptability::Unblock()
+{
+    MOZ_ASSERT(mScriptBlocks > 0);
+    --mScriptBlocks;
+}
+
+void
+Scriptability::SetDocShellAllowsScript(bool aAllowed)
+{
+    mDocShellAllowsScript = aAllowed || mImmuneToScriptPolicy;
+}
+
+/* static */
+Scriptability&
+Scriptability::Get(JSObject* aScope)
+{
+    return CompartmentPrivate::Get(aScope)->scriptability;
+}
+
+bool
+IsContentXBLScope(JSCompartment* compartment)
+{
+    // We always eagerly create compartment privates for XBL scopes.
+    CompartmentPrivate* priv = CompartmentPrivate::Get(compartment);
+    if (!priv || !priv->scope)
+        return false;
+    return priv->scope->IsContentXBLScope();
+}
+
+bool
+IsInContentXBLScope(JSObject* obj)
+{
+    return IsContentXBLScope(js::GetObjectCompartment(obj));
+}
+
+bool
+IsInAddonScope(JSObject* obj)
+{
+    return ObjectScope(obj)->IsAddonScope();
+}
+
+bool
+IsUniversalXPConnectEnabled(JSCompartment* compartment)
+{
+    CompartmentPrivate* priv = CompartmentPrivate::Get(compartment);
+    if (!priv)
+        return false;
+    return priv->universalXPConnectEnabled;
+}
+
+bool
+IsUniversalXPConnectEnabled(JSContext* cx)
+{
+    JSCompartment* compartment = js::GetContextCompartment(cx);
+    if (!compartment)
+        return false;
+    return IsUniversalXPConnectEnabled(compartment);
+}
+
+bool
+EnableUniversalXPConnect(JSContext* cx)
+{
+    JSCompartment* compartment = js::GetContextCompartment(cx);
+    if (!compartment)
+        return true;
+    // Never set universalXPConnectEnabled on a chrome compartment - it confuses
+    // the security wrapping code.
+    if (AccessCheck::isChrome(compartment))
+        return true;
+    CompartmentPrivate* priv = CompartmentPrivate::Get(compartment);
+    if (!priv)
+        return true;
+    if (priv->universalXPConnectEnabled)
+        return true;
+    priv->universalXPConnectEnabled = true;
+
+    // Recompute all the cross-compartment wrappers leaving the newly-privileged
+    // compartment.
+    bool ok = js::RecomputeWrappers(cx, js::SingleCompartment(compartment),
+                                    js::AllCompartments());
+    NS_ENSURE_TRUE(ok, false);
+
+    // The Components object normally isn't defined for unprivileged web content,
+    // but we define it when UniversalXPConnect is enabled to support legacy
+    // tests.
+    XPCWrappedNativeScope* scope = priv->scope;
+    if (!scope)
+        return true;
+    scope->ForcePrivilegedComponents();
+    return scope->AttachComponentsObject(cx);
+}
+
+JSObject*
+UnprivilegedJunkScope()
+{
+    return XPCJSContext::Get()->UnprivilegedJunkScope();
+}
+
+JSObject*
+PrivilegedJunkScope()
+{
+    return XPCJSContext::Get()->PrivilegedJunkScope();
+}
+
+JSObject*
+CompilationScope()
+{
+    return XPCJSContext::Get()->CompilationScope();
+}
+
+nsGlobalWindow*
+WindowOrNull(JSObject* aObj)
+{
+    MOZ_ASSERT(aObj);
+    MOZ_ASSERT(!js::IsWrapper(aObj));
+
+    nsGlobalWindow* win = nullptr;
+    UNWRAP_NON_WRAPPER_OBJECT(Window, aObj, win);
+    return win;
+}
+
+nsGlobalWindow*
+WindowGlobalOrNull(JSObject* aObj)
+{
+    MOZ_ASSERT(aObj);
+    JSObject* glob = js::GetGlobalForObjectCrossCompartment(aObj);
+
+    return WindowOrNull(glob);
+}
+
+nsGlobalWindow*
+AddonWindowOrNull(JSObject* aObj)
+{
+    if (!IsInAddonScope(aObj))
+        return nullptr;
+
+    JSObject* global = js::GetGlobalForObjectCrossCompartment(aObj);
+    JSObject* proto = js::GetPrototypeNoProxy(global);
+
+    // Addons could theoretically change the prototype of the addon scope, but
+    // we pretty much just want to crash if that happens so that we find out
+    // about it and get them to change their code.
+    MOZ_RELEASE_ASSERT(js::IsCrossCompartmentWrapper(proto) ||
+                       xpc::IsSandboxPrototypeProxy(proto));
+    JSObject* mainGlobal = js::UncheckedUnwrap(proto, /* stopAtWindowProxy = */ false);
+    MOZ_RELEASE_ASSERT(JS_IsGlobalObject(mainGlobal));
+
+    return WindowOrNull(mainGlobal);
+}
+
+nsGlobalWindow*
+CurrentWindowOrNull(JSContext* cx)
+{
+    JSObject* glob = JS::CurrentGlobalOrNull(cx);
+    return glob ? WindowOrNull(glob) : nullptr;
+}
+
+} // namespace xpc
+
+static void
+CompartmentDestroyedCallback(JSFreeOp* fop, JSCompartment* compartment)
+{
+    // NB - This callback may be called in JS_DestroyContext, which happens
+    // after the XPCJSContext has been torn down.
+
+    // Get the current compartment private into an AutoPtr (which will do the
+    // cleanup for us), and null out the private (which may already be null).
+    nsAutoPtr<CompartmentPrivate> priv(CompartmentPrivate::Get(compartment));
+    JS_SetCompartmentPrivate(compartment, nullptr);
+}
+
+static size_t
+CompartmentSizeOfIncludingThisCallback(MallocSizeOf mallocSizeOf, JSCompartment* compartment)
+{
+    CompartmentPrivate* priv = CompartmentPrivate::Get(compartment);
+    return priv ? priv->SizeOfIncludingThis(mallocSizeOf) : 0;
+}
+
+/*
+ * Return true if there exists a non-system inner window which is a current
+ * inner window and whose reflector is gray.  We don't merge system
+ * compartments, so we don't use them to trigger merging CCs.
+ */
+bool XPCJSContext::UsefulToMergeZones() const
+{
+    MOZ_ASSERT(NS_IsMainThread());
+
+    // Turns out, actually making this return true often enough makes Windows
+    // mochitest-gl OOM a lot.  Need to figure out what's going on there; see
+    // bug 1277036.
+
+    return false;
+}
+
+void XPCJSContext::TraceNativeBlackRoots(JSTracer* trc)
+{
+    if (AutoMarkingPtr* roots = Get()->mAutoRoots)
+        roots->TraceJSAll(trc);
+
+    // XPCJSObjectHolders don't participate in cycle collection, so always
+    // trace them here.
+    XPCRootSetElem* e;
+    for (e = mObjectHolderRoots; e; e = e->GetNextRoot())
+        static_cast<XPCJSObjectHolder*>(e)->TraceJS(trc);
+
+    dom::TraceBlackJS(trc, JS_GetGCParameter(Context(), JSGC_NUMBER),
+                      nsXPConnect::XPConnect()->IsShuttingDown());
+}
+
+void XPCJSContext::TraceAdditionalNativeGrayRoots(JSTracer* trc)
+{
+    XPCWrappedNativeScope::TraceWrappedNativesInAllScopes(trc, this);
+
+    for (XPCRootSetElem* e = mVariantRoots; e ; e = e->GetNextRoot())
+        static_cast<XPCTraceableVariant*>(e)->TraceJS(trc);
+
+    for (XPCRootSetElem* e = mWrappedJSRoots; e ; e = e->GetNextRoot())
+        static_cast<nsXPCWrappedJS*>(e)->TraceJS(trc);
+}
+
+void
+XPCJSContext::TraverseAdditionalNativeRoots(nsCycleCollectionNoteRootCallback& cb)
+{
+    XPCWrappedNativeScope::SuspectAllWrappers(this, cb);
+
+    for (XPCRootSetElem* e = mVariantRoots; e ; e = e->GetNextRoot()) {
+        XPCTraceableVariant* v = static_cast<XPCTraceableVariant*>(e);
+        if (nsCCUncollectableMarker::InGeneration(cb,
+                                                  v->CCGeneration())) {
+           JS::Value val = v->GetJSValPreserveColor();
+           if (val.isObject() && !JS::ObjectIsMarkedGray(&val.toObject()))
+               continue;
+        }
+        cb.NoteXPCOMRoot(v);
+    }
+
+    for (XPCRootSetElem* e = mWrappedJSRoots; e ; e = e->GetNextRoot()) {
+        cb.NoteXPCOMRoot(ToSupports(static_cast<nsXPCWrappedJS*>(e)));
+    }
+}
+
+void
+XPCJSContext::UnmarkSkippableJSHolders()
+{
+    CycleCollectedJSContext::UnmarkSkippableJSHolders();
+}
+
+void
+XPCJSContext::PrepareForForgetSkippable()
+{
+    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    if (obs) {
+        obs->NotifyObservers(nullptr, "cycle-collector-forget-skippable", nullptr);
+    }
+}
+
+void
+XPCJSContext::BeginCycleCollectionCallback()
+{
+    nsJSContext::BeginCycleCollectionCallback();
+
+    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    if (obs) {
+        obs->NotifyObservers(nullptr, "cycle-collector-begin", nullptr);
+    }
+}
+
+void
+XPCJSContext::EndCycleCollectionCallback(CycleCollectorResults& aResults)
+{
+    nsJSContext::EndCycleCollectionCallback(aResults);
+
+    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    if (obs) {
+        obs->NotifyObservers(nullptr, "cycle-collector-end", nullptr);
+    }
+}
+
+void
+XPCJSContext::DispatchDeferredDeletion(bool aContinuation, bool aPurge)
+{
+    mAsyncSnowWhiteFreer->Dispatch(aContinuation, aPurge);
+}
+
+void
+xpc_UnmarkSkippableJSHolders()
+{
+    if (nsXPConnect::XPConnect()->GetContext()) {
+        nsXPConnect::XPConnect()->GetContext()->UnmarkSkippableJSHolders();
+    }
+}
+
+/* static */ void
+XPCJSContext::GCSliceCallback(JSContext* cx,
+                              JS::GCProgress progress,
+                              const JS::GCDescription& desc)
+{
+    XPCJSContext* self = nsXPConnect::GetContextInstance();
+    if (!self)
+        return;
+
+#ifdef MOZ_CRASHREPORTER
+    CrashReporter::SetGarbageCollecting(progress == JS::GC_CYCLE_BEGIN ||
+                                        progress == JS::GC_SLICE_BEGIN);
+#endif
+
+    if (self->mPrevGCSliceCallback)
+        (*self->mPrevGCSliceCallback)(cx, progress, desc);
+}
+
+/* static */ void
+XPCJSContext::DoCycleCollectionCallback(JSContext* cx)
+{
+    // The GC has detected that a CC at this point would collect a tremendous
+    // amount of garbage that is being revivified unnecessarily.
+    NS_DispatchToCurrentThread(
+            NS_NewRunnableFunction([](){nsJSContext::CycleCollectNow(nullptr);}));
+
+    XPCJSContext* self = nsXPConnect::GetContextInstance();
+    if (!self)
+        return;
+
+    if (self->mPrevDoCycleCollectionCallback)
+        (*self->mPrevDoCycleCollectionCallback)(cx);
+}
+
+void
+XPCJSContext::CustomGCCallback(JSGCStatus status)
+{
+    nsTArray<xpcGCCallback> callbacks(extraGCCallbacks);
+    for (uint32_t i = 0; i < callbacks.Length(); ++i)
+        callbacks[i](status);
+}
+
+/* static */ void
+XPCJSContext::FinalizeCallback(JSFreeOp* fop,
+                               JSFinalizeStatus status,
+                               bool isZoneGC,
+                               void* data)
+{
+    XPCJSContext* self = nsXPConnect::GetContextInstance();
+    if (!self)
+        return;
+
+    switch (status) {
+        case JSFINALIZE_GROUP_START:
+        {
+            MOZ_ASSERT(!self->mDoingFinalization, "bad state");
+
+            MOZ_ASSERT(!self->mGCIsRunning, "bad state");
+            self->mGCIsRunning = true;
+
+            self->mDoingFinalization = true;
+            break;
+        }
+        case JSFINALIZE_GROUP_END:
+        {
+            MOZ_ASSERT(self->mDoingFinalization, "bad state");
+            self->mDoingFinalization = false;
+
+            // Sweep scopes needing cleanup
+            XPCWrappedNativeScope::KillDyingScopes();
+
+            MOZ_ASSERT(self->mGCIsRunning, "bad state");
+            self->mGCIsRunning = false;
+
+            break;
+        }
+        case JSFINALIZE_COLLECTION_END:
+        {
+            MOZ_ASSERT(!self->mGCIsRunning, "bad state");
+            self->mGCIsRunning = true;
+
+            if (AutoMarkingPtr* roots = Get()->mAutoRoots)
+                roots->MarkAfterJSFinalizeAll();
+
+            // Now we are going to recycle any unused WrappedNativeTearoffs.
+            // We do this by iterating all the live callcontexts
+            // and marking the tearoffs in use. And then we
+            // iterate over all the WrappedNative wrappers and sweep their
+            // tearoffs.
+            //
+            // This allows us to perhaps minimize the growth of the
+            // tearoffs. And also makes us not hold references to interfaces
+            // on our wrapped natives that we are not actually using.
+            //
+            // XXX We may decide to not do this on *every* gc cycle.
+
+            XPCCallContext* ccxp = XPCJSContext::Get()->GetCallContext();
+            while (ccxp) {
+                // Deal with the strictness of callcontext that
+                // complains if you ask for a tearoff when
+                // it is in a state where the tearoff could not
+                // possibly be valid.
+                if (ccxp->CanGetTearOff()) {
+                    XPCWrappedNativeTearOff* to =
+                        ccxp->GetTearOff();
+                    if (to)
+                        to->Mark();
+                }
+                ccxp = ccxp->GetPrevCallContext();
+            }
+
+            XPCWrappedNativeScope::SweepAllWrappedNativeTearOffs();
+
+            // Now we need to kill the 'Dying' XPCWrappedNativeProtos.
+            // We transfered these native objects to this table when their
+            // JSObject's were finalized. We did not destroy them immediately
+            // at that point because the ordering of JS finalization is not
+            // deterministic and we did not yet know if any wrappers that
+            // might still be referencing the protos where still yet to be
+            // finalized and destroyed. We *do* know that the protos'
+            // JSObjects would not have been finalized if there were any
+            // wrappers that referenced the proto but where not themselves
+            // slated for finalization in this gc cycle. So... at this point
+            // we know that any and all wrappers that might have been
+            // referencing the protos in the dying list are themselves dead.
+            // So, we can safely delete all the protos in the list.
+
+            for (auto i = self->mDyingWrappedNativeProtoMap->Iter(); !i.Done(); i.Next()) {
+                auto entry = static_cast<XPCWrappedNativeProtoMap::Entry*>(i.Get());
+                delete static_cast<const XPCWrappedNativeProto*>(entry->key);
+                i.Remove();
+            }
+
+            MOZ_ASSERT(self->mGCIsRunning, "bad state");
+            self->mGCIsRunning = false;
+
+            break;
+        }
+    }
+}
+
+/* static */ void
+XPCJSContext::WeakPointerZoneGroupCallback(JSContext* cx, void* data)
+{
+    // Called before each sweeping slice -- after processing any final marking
+    // triggered by barriers -- to clear out any references to things that are
+    // about to be finalized and update any pointers to moved GC things.
+    XPCJSContext* self = static_cast<XPCJSContext*>(data);
+
+    self->mWrappedJSMap->UpdateWeakPointersAfterGC(self);
+
+    XPCWrappedNativeScope::UpdateWeakPointersAfterGC(self);
+}
+
+/* static */ void
+XPCJSContext::WeakPointerCompartmentCallback(JSContext* cx, JSCompartment* comp, void* data)
+{
+    // Called immediately after the ZoneGroup weak pointer callback, but only
+    // once for each compartment that is being swept.
+    XPCJSContext* self = static_cast<XPCJSContext*>(data);
+    CompartmentPrivate* xpcComp = CompartmentPrivate::Get(comp);
+    if (xpcComp)
+        xpcComp->UpdateWeakPointersAfterGC(self);
+}
+
+void
+CompartmentPrivate::UpdateWeakPointersAfterGC(XPCJSContext* context)
+{
+    mWrappedJSMap->UpdateWeakPointersAfterGC(context);
+}
+
+static void WatchdogMain(void* arg);
+class Watchdog;
+class WatchdogManager;
+class AutoLockWatchdog {
+    Watchdog* const mWatchdog;
+  public:
+    explicit AutoLockWatchdog(Watchdog* aWatchdog);
+    ~AutoLockWatchdog();
+};
+
+class Watchdog
+{
+  public:
+    explicit Watchdog(WatchdogManager* aManager)
+      : mManager(aManager)
+      , mLock(nullptr)
+      , mWakeup(nullptr)
+      , mThread(nullptr)
+      , mHibernating(false)
+      , mInitialized(false)
+      , mShuttingDown(false)
+      , mMinScriptRunTimeSeconds(1)
+    {}
+    ~Watchdog() { MOZ_ASSERT(!Initialized()); }
+
+    WatchdogManager* Manager() { return mManager; }
+    bool Initialized() { return mInitialized; }
+    bool ShuttingDown() { return mShuttingDown; }
+    PRLock* GetLock() { return mLock; }
+    bool Hibernating() { return mHibernating; }
+    void WakeUp()
+    {
+        MOZ_ASSERT(Initialized());
+        MOZ_ASSERT(Hibernating());
+        mHibernating = false;
+        PR_NotifyCondVar(mWakeup);
+    }
+
+    //
+    // Invoked by the main thread only.
+    //
+
+    void Init()
+    {
+        MOZ_ASSERT(NS_IsMainThread());
+        mLock = PR_NewLock();
+        if (!mLock)
+            NS_RUNTIMEABORT("PR_NewLock failed.");
+        mWakeup = PR_NewCondVar(mLock);
+        if (!mWakeup)
+            NS_RUNTIMEABORT("PR_NewCondVar failed.");
+
+        {
+            AutoLockWatchdog lock(this);
+
+            // Gecko uses thread private for accounting and has to clean up at thread exit.
+            // Therefore, even though we don't have a return value from the watchdog, we need to
+            // join it on shutdown.
+            mThread = PR_CreateThread(PR_USER_THREAD, WatchdogMain, this,
+                                      PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
+                                      PR_JOINABLE_THREAD, 0);
+            if (!mThread)
+                NS_RUNTIMEABORT("PR_CreateThread failed!");
+
+            // WatchdogMain acquires the lock and then asserts mInitialized. So
+            // make sure to set mInitialized before releasing the lock here so
+            // that it's atomic with the creation of the thread.
+            mInitialized = true;
+        }
+    }
+
+    void Shutdown()
+    {
+        MOZ_ASSERT(NS_IsMainThread());
+        MOZ_ASSERT(Initialized());
+        {   // Scoped lock.
+            AutoLockWatchdog lock(this);
+
+            // Signal to the watchdog thread that it's time to shut down.
+            mShuttingDown = true;
+
+            // Wake up the watchdog, and wait for it to call us back.
+            PR_NotifyCondVar(mWakeup);
+        }
+
+        PR_JoinThread(mThread);
+
+        // The thread sets mShuttingDown to false as it exits.
+        MOZ_ASSERT(!mShuttingDown);
+
+        // Destroy state.
+        mThread = nullptr;
+        PR_DestroyCondVar(mWakeup);
+        mWakeup = nullptr;
+        PR_DestroyLock(mLock);
+        mLock = nullptr;
+
+        // All done.
+        mInitialized = false;
+    }
+
+    void SetMinScriptRunTimeSeconds(int32_t seconds)
+    {
+        // This variable is atomic, and is set from the main thread without
+        // locking.
+        MOZ_ASSERT(seconds > 0);
+        mMinScriptRunTimeSeconds = seconds;
+    }
+
+    //
+    // Invoked by the watchdog thread only.
+    //
+
+    void Hibernate()
+    {
+        MOZ_ASSERT(!NS_IsMainThread());
+        mHibernating = true;
+        Sleep(PR_INTERVAL_NO_TIMEOUT);
+    }
+    void Sleep(PRIntervalTime timeout)
+    {
+        MOZ_ASSERT(!NS_IsMainThread());
+        MOZ_ALWAYS_TRUE(PR_WaitCondVar(mWakeup, timeout) == PR_SUCCESS);
+    }
+    void Finished()
+    {
+        MOZ_ASSERT(!NS_IsMainThread());
+        mShuttingDown = false;
+    }
+
+    int32_t MinScriptRunTimeSeconds()
+    {
+        return mMinScriptRunTimeSeconds;
+    }
+
+  private:
+    WatchdogManager* mManager;
+
+    PRLock* mLock;
+    PRCondVar* mWakeup;
+    PRThread* mThread;
+    bool mHibernating;
+    bool mInitialized;
+    bool mShuttingDown;
+    mozilla::Atomic<int32_t> mMinScriptRunTimeSeconds;
+};
+
+#define PREF_MAX_SCRIPT_RUN_TIME_CONTENT "dom.max_script_run_time"
+#define PREF_MAX_SCRIPT_RUN_TIME_CHROME "dom.max_chrome_script_run_time"
+
+class WatchdogManager : public nsIObserver
+{
+  public:
+
+    NS_DECL_ISUPPORTS
+    explicit WatchdogManager(XPCJSContext* aContext) : mContext(aContext)
+                                                     , mContextState(CONTEXT_INACTIVE)
+    {
+        // All the timestamps start at zero except for context state change.
+        PodArrayZero(mTimestamps);
+        mTimestamps[TimestampContextStateChange] = PR_Now();
+
+        // Enable the watchdog, if appropriate.
+        RefreshWatchdog();
+
+        // Register ourselves as an observer to get updates on the pref.
+        mozilla::Preferences::AddStrongObserver(this, "dom.use_watchdog");
+        mozilla::Preferences::AddStrongObserver(this, PREF_MAX_SCRIPT_RUN_TIME_CONTENT);
+        mozilla::Preferences::AddStrongObserver(this, PREF_MAX_SCRIPT_RUN_TIME_CHROME);
+    }
+
+  protected:
+
+    virtual ~WatchdogManager()
+    {
+        // Shutting down the watchdog requires context-switching to the watchdog
+        // thread, which isn't great to do in a destructor. So we require
+        // consumers to shut it down manually before releasing it.
+        MOZ_ASSERT(!mWatchdog);
+        mozilla::Preferences::RemoveObserver(this, "dom.use_watchdog");
+        mozilla::Preferences::RemoveObserver(this, PREF_MAX_SCRIPT_RUN_TIME_CONTENT);
+        mozilla::Preferences::RemoveObserver(this, PREF_MAX_SCRIPT_RUN_TIME_CHROME);
+    }
+
+  public:
+
+    NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
+                       const char16_t* aData) override
+    {
+        RefreshWatchdog();
+        return NS_OK;
+    }
+
+    // Context statistics. These live on the watchdog manager, are written
+    // from the main thread, and are read from the watchdog thread (holding
+    // the lock in each case).
+    void
+    RecordContextActivity(bool active)
+    {
+        // The watchdog reads this state, so acquire the lock before writing it.
+        MOZ_ASSERT(NS_IsMainThread());
+        Maybe<AutoLockWatchdog> lock;
+        if (mWatchdog)
+            lock.emplace(mWatchdog);
+
+        // Write state.
+        mTimestamps[TimestampContextStateChange] = PR_Now();
+        mContextState = active ? CONTEXT_ACTIVE : CONTEXT_INACTIVE;
+
+        // The watchdog may be hibernating, waiting for the context to go
+        // active. Wake it up if necessary.
+        if (active && mWatchdog && mWatchdog->Hibernating())
+            mWatchdog->WakeUp();
+    }
+    bool IsContextActive() { return mContextState == CONTEXT_ACTIVE; }
+    PRTime TimeSinceLastContextStateChange()
+    {
+        return PR_Now() - GetTimestamp(TimestampContextStateChange);
+    }
+
+    // Note - Because of the context activity timestamp, these are read and
+    // written from both threads.
+    void RecordTimestamp(WatchdogTimestampCategory aCategory)
+    {
+        // The watchdog thread always holds the lock when it runs.
+        Maybe<AutoLockWatchdog> maybeLock;
+        if (NS_IsMainThread() && mWatchdog)
+            maybeLock.emplace(mWatchdog);
+        mTimestamps[aCategory] = PR_Now();
+    }
+    PRTime GetTimestamp(WatchdogTimestampCategory aCategory)
+    {
+        // The watchdog thread always holds the lock when it runs.
+        Maybe<AutoLockWatchdog> maybeLock;
+        if (NS_IsMainThread() && mWatchdog)
+            maybeLock.emplace(mWatchdog);
+        return mTimestamps[aCategory];
+    }
+
+    XPCJSContext* Context() { return mContext; }
+    Watchdog* GetWatchdog() { return mWatchdog; }
+
+    void RefreshWatchdog()
+    {
+        bool wantWatchdog = Preferences::GetBool("dom.use_watchdog", true);
+        if (wantWatchdog != !!mWatchdog) {
+            if (wantWatchdog)
+                StartWatchdog();
+            else
+                StopWatchdog();
+        }
+
+        if (mWatchdog) {
+            int32_t contentTime = Preferences::GetInt(PREF_MAX_SCRIPT_RUN_TIME_CONTENT, 10);
+            if (contentTime <= 0)
+                contentTime = INT32_MAX;
+            int32_t chromeTime = Preferences::GetInt(PREF_MAX_SCRIPT_RUN_TIME_CHROME, 20);
+            if (chromeTime <= 0)
+                chromeTime = INT32_MAX;
+            mWatchdog->SetMinScriptRunTimeSeconds(std::min(contentTime, chromeTime));
+        }
+    }
+
+    void StartWatchdog()
+    {
+        MOZ_ASSERT(!mWatchdog);
+        mWatchdog = new Watchdog(this);
+        mWatchdog->Init();
+    }
+
+    void StopWatchdog()
+    {
+        MOZ_ASSERT(mWatchdog);
+        mWatchdog->Shutdown();
+        mWatchdog = nullptr;
+    }
+
+  private:
+    XPCJSContext* mContext;
+    nsAutoPtr<Watchdog> mWatchdog;
+
+    enum { CONTEXT_ACTIVE, CONTEXT_INACTIVE } mContextState;
+    PRTime mTimestamps[TimestampCount];
+};
+
+NS_IMPL_ISUPPORTS(WatchdogManager, nsIObserver)
+
+AutoLockWatchdog::AutoLockWatchdog(Watchdog* aWatchdog) : mWatchdog(aWatchdog)
+{
+    PR_Lock(mWatchdog->GetLock());
+}
+
+AutoLockWatchdog::~AutoLockWatchdog()
+{
+    PR_Unlock(mWatchdog->GetLock());
+}
+
+static void
+WatchdogMain(void* arg)
+{
+    PR_SetCurrentThreadName("JS Watchdog");
+
+    Watchdog* self = static_cast<Watchdog*>(arg);
+    WatchdogManager* manager = self->Manager();
+
+    // Lock lasts until we return
+    AutoLockWatchdog lock(self);
+
+    MOZ_ASSERT(self->Initialized());
+    MOZ_ASSERT(!self->ShuttingDown());
+    while (!self->ShuttingDown()) {
+        // Sleep only 1 second if recently (or currently) active; otherwise, hibernate
+        if (manager->IsContextActive() ||
+            manager->TimeSinceLastContextStateChange() <= PRTime(2*PR_USEC_PER_SEC))
+        {
+            self->Sleep(PR_TicksPerSecond());
+        } else {
+            manager->RecordTimestamp(TimestampWatchdogHibernateStart);
+            self->Hibernate();
+            manager->RecordTimestamp(TimestampWatchdogHibernateStop);
+        }
+
+        // Rise and shine.
+        manager->RecordTimestamp(TimestampWatchdogWakeup);
+
+        // Don't request an interrupt callback unless the current script has
+        // been running long enough that we might show the slow script dialog.
+        // Triggering the callback from off the main thread can be expensive.
+
+        // We want to avoid showing the slow script dialog if the user's laptop
+        // goes to sleep in the middle of running a script. To ensure this, we
+        // invoke the interrupt callback after only half the timeout has
+        // elapsed. The callback simply records the fact that it was called in
+        // the mSlowScriptSecondHalf flag. Then we wait another (timeout/2)
+        // seconds and invoke the callback again. This time around it sees
+        // mSlowScriptSecondHalf is set and so it shows the slow script
+        // dialog. If the computer is put to sleep during one of the (timeout/2)
+        // periods, the script still has the other (timeout/2) seconds to
+        // finish.
+        PRTime usecs = self->MinScriptRunTimeSeconds() * PR_USEC_PER_SEC / 2;
+        if (manager->IsContextActive() &&
+            manager->TimeSinceLastContextStateChange() >= usecs)
+        {
+            bool debuggerAttached = false;
+            nsCOMPtr<nsIDebug2> dbg = do_GetService("@mozilla.org/xpcom/debug;1");
+            if (dbg)
+                dbg->GetIsDebuggerAttached(&debuggerAttached);
+            if (!debuggerAttached)
+                JS_RequestInterruptCallback(manager->Context()->Context());
+        }
+    }
+
+    // Tell the manager that we've shut down.
+    self->Finished();
+}
+
+PRTime
+XPCJSContext::GetWatchdogTimestamp(WatchdogTimestampCategory aCategory)
+{
+    return mWatchdogManager->GetTimestamp(aCategory);
+}
+
+void
+xpc::SimulateActivityCallback(bool aActive)
+{
+    XPCJSContext::ActivityCallback(XPCJSContext::Get(), aActive);
+}
+
+// static
+void
+XPCJSContext::ActivityCallback(void* arg, bool active)
+{
+    if (!active) {
+        ProcessHangMonitor::ClearHang();
+    }
+
+    XPCJSContext* self = static_cast<XPCJSContext*>(arg);
+    self->mWatchdogManager->RecordContextActivity(active);
+}
+
+// static
+bool
+XPCJSContext::InterruptCallback(JSContext* cx)
+{
+    XPCJSContext* self = XPCJSContext::Get();
+
+    // Normally we record mSlowScriptCheckpoint when we start to process an
+    // event. However, we can run JS outside of event handlers. This code takes
+    // care of that case.
+    if (self->mSlowScriptCheckpoint.IsNull()) {
+        self->mSlowScriptCheckpoint = TimeStamp::NowLoRes();
+        self->mSlowScriptSecondHalf = false;
+        self->mSlowScriptActualWait = mozilla::TimeDuration();
+        self->mTimeoutAccumulated = false;
+        return true;
+    }
+
+    // Sometimes we get called back during XPConnect initialization, before Gecko
+    // has finished bootstrapping. Avoid crashing in nsContentUtils below.
+    if (!nsContentUtils::IsInitialized())
+        return true;
+
+    // This is at least the second interrupt callback we've received since
+    // returning to the event loop. See how long it's been, and what the limit
+    // is.
+    TimeDuration duration = TimeStamp::NowLoRes() - self->mSlowScriptCheckpoint;
+    bool chrome = nsContentUtils::IsCallerChrome();
+    const char* prefName = chrome ? PREF_MAX_SCRIPT_RUN_TIME_CHROME
+                                  : PREF_MAX_SCRIPT_RUN_TIME_CONTENT;
+    int32_t limit = Preferences::GetInt(prefName, chrome ? 20 : 10);
+
+    // If there's no limit, or we're within the limit, let it go.
+    if (limit == 0 || duration.ToSeconds() < limit / 2.0)
+        return true;
+
+    self->mSlowScriptActualWait += duration;
+
+    // In order to guard against time changes or laptops going to sleep, we
+    // don't trigger the slow script warning until (limit/2) seconds have
+    // elapsed twice.
+    if (!self->mSlowScriptSecondHalf) {
+        self->mSlowScriptCheckpoint = TimeStamp::NowLoRes();
+        self->mSlowScriptSecondHalf = true;
+        return true;
+    }
+
+    //
+    // This has gone on long enough! Time to take action. ;-)
+    //
+
+    // Get the DOM window associated with the running script. If the script is
+    // running in a non-DOM scope, we have to just let it keep running.
+    RootedObject global(cx, JS::CurrentGlobalOrNull(cx));
+    RefPtr<nsGlobalWindow> win = WindowOrNull(global);
+    if (!win && IsSandbox(global)) {
+        // If this is a sandbox associated with a DOMWindow via a
+        // sandboxPrototype, use that DOMWindow. This supports GreaseMonkey
+        // and JetPack content scripts.
+        JS::Rooted<JSObject*> proto(cx);
+        if (!JS_GetPrototype(cx, global, &proto))
+            return false;
+        if (proto && IsSandboxPrototypeProxy(proto) &&
+            (proto = js::CheckedUnwrap(proto, /* stopAtWindowProxy = */ false)))
+        {
+            win = WindowGlobalOrNull(proto);
+        }
+    }
+
+    if (!win) {
+        NS_WARNING("No active window");
+        return true;
+    }
+
+    if (win->IsDying()) {
+        // The window is being torn down. When that happens we try to prevent
+        // the dispatch of new runnables, so it also makes sense to kill any
+        // long-running script. The user is primarily interested in this page
+        // going away.
+        return false;
+    }
+
+    if (win->GetIsPrerendered()) {
+        // We cannot display a dialog if the page is being prerendered, so
+        // just kill the page.
+        mozilla::dom::HandlePrerenderingViolation(win->AsInner());
+        return false;
+    }
+
+    // Accumulate slow script invokation delay.
+    if (!chrome && !self->mTimeoutAccumulated) {
+      uint32_t delay = uint32_t(self->mSlowScriptActualWait.ToMilliseconds() - (limit * 1000.0));
+      Telemetry::Accumulate(Telemetry::SLOW_SCRIPT_NOTIFY_DELAY, delay);
+      self->mTimeoutAccumulated = true;
+    }
+
+    // Show the prompt to the user, and kill if requested.
+    nsGlobalWindow::SlowScriptResponse response = win->ShowSlowScriptDialog();
+    if (response == nsGlobalWindow::KillSlowScript) {
+        if (Preferences::GetBool("dom.global_stop_script", true))
+            xpc::Scriptability::Get(global).Block();
+        return false;
+    }
+
+    // The user chose to continue the script. Reset the timer, and disable this
+    // machinery with a pref of the user opted out of future slow-script dialogs.
+    if (response != nsGlobalWindow::ContinueSlowScriptAndKeepNotifying)
+        self->mSlowScriptCheckpoint = TimeStamp::NowLoRes();
+
+    if (response == nsGlobalWindow::AlwaysContinueSlowScript)
+        Preferences::SetInt(prefName, 0);
+
+    return true;
+}
+
+void
+XPCJSContext::CustomOutOfMemoryCallback()
+{
+    if (!Preferences::GetBool("memory.dump_reports_on_oom")) {
+        return;
+    }
+
+    nsCOMPtr<nsIMemoryInfoDumper> dumper =
+        do_GetService("@mozilla.org/memory-info-dumper;1");
+    if (!dumper) {
+        return;
+    }
+
+    // If this fails, it fails silently.
+    dumper->DumpMemoryInfoToTempDir(NS_LITERAL_STRING("due-to-JS-OOM"),
+                                    /* anonymize = */ false,
+                                    /* minimizeMemoryUsage = */ false);
+}
+
+void
+XPCJSContext::CustomLargeAllocationFailureCallback()
+{
+    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+    if (os) {
+        os->NotifyObservers(nullptr, "memory-pressure", u"heap-minimize");
+    }
+}
+
+size_t
+XPCJSContext::SizeOfIncludingThis(MallocSizeOf mallocSizeOf)
+{
+    size_t n = 0;
+    n += mallocSizeOf(this);
+    n += mWrappedJSMap->SizeOfIncludingThis(mallocSizeOf);
+    n += mIID2NativeInterfaceMap->SizeOfIncludingThis(mallocSizeOf);
+    n += mClassInfo2NativeSetMap->ShallowSizeOfIncludingThis(mallocSizeOf);
+    n += mNativeSetMap->SizeOfIncludingThis(mallocSizeOf);
+
+    n += CycleCollectedJSContext::SizeOfExcludingThis(mallocSizeOf);
+
+    // There are other XPCJSContext members that could be measured; the above
+    // ones have been seen by DMD to be worth measuring.  More stuff may be
+    // added later.
+
+    return n;
+}
+
+size_t
+CompartmentPrivate::SizeOfIncludingThis(MallocSizeOf mallocSizeOf)
+{
+    size_t n = mallocSizeOf(this);
+    n += mWrappedJSMap->SizeOfIncludingThis(mallocSizeOf);
+    n += mWrappedJSMap->SizeOfWrappedJS(mallocSizeOf);
+    return n;
+}
+
+/***************************************************************************/
+
+#define JS_OPTIONS_DOT_STR "javascript.options."
+
+static void
+ReloadPrefsCallback(const char* pref, void* data)
+{
+    XPCJSContext* xpccx = reinterpret_cast<XPCJSContext*>(data);
+    JSContext* cx = xpccx->Context();
+
+    bool safeMode = false;
+    nsCOMPtr<nsIXULRuntime> xr = do_GetService("@mozilla.org/xre/runtime;1");
+    if (xr) {
+        xr->GetInSafeMode(&safeMode);
+    }
+
+    bool useBaseline = Preferences::GetBool(JS_OPTIONS_DOT_STR "baselinejit") && !safeMode;
+    bool useIon = Preferences::GetBool(JS_OPTIONS_DOT_STR "ion") && !safeMode;
+    bool useAsmJS = Preferences::GetBool(JS_OPTIONS_DOT_STR "asmjs") && !safeMode;
+    bool useWasm = Preferences::GetBool(JS_OPTIONS_DOT_STR "wasm") && !safeMode;
+    bool useWasmBaseline = Preferences::GetBool(JS_OPTIONS_DOT_STR "wasm_baselinejit") && !safeMode;
+    bool throwOnAsmJSValidationFailure = Preferences::GetBool(JS_OPTIONS_DOT_STR
+                                                              "throw_on_asmjs_validation_failure");
+    bool useNativeRegExp = Preferences::GetBool(JS_OPTIONS_DOT_STR "native_regexp") && !safeMode;
+
+    bool parallelParsing = Preferences::GetBool(JS_OPTIONS_DOT_STR "parallel_parsing");
+    bool offthreadIonCompilation = Preferences::GetBool(JS_OPTIONS_DOT_STR
+                                                       "ion.offthread_compilation");
+    bool useBaselineEager = Preferences::GetBool(JS_OPTIONS_DOT_STR
+                                                 "baselinejit.unsafe_eager_compilation");
+    bool useIonEager = Preferences::GetBool(JS_OPTIONS_DOT_STR "ion.unsafe_eager_compilation");
+
+    sDiscardSystemSource = Preferences::GetBool(JS_OPTIONS_DOT_STR "discardSystemSource");
+
+    bool useAsyncStack = Preferences::GetBool(JS_OPTIONS_DOT_STR "asyncstack");
+
+    bool throwOnDebuggeeWouldRun = Preferences::GetBool(JS_OPTIONS_DOT_STR
+                                                        "throw_on_debuggee_would_run");
+
+    bool dumpStackOnDebuggeeWouldRun = Preferences::GetBool(JS_OPTIONS_DOT_STR
+                                                            "dump_stack_on_debuggee_would_run");
+
+    bool werror = Preferences::GetBool(JS_OPTIONS_DOT_STR "werror");
+
+    bool extraWarnings = Preferences::GetBool(JS_OPTIONS_DOT_STR "strict");
+
+    sSharedMemoryEnabled = Preferences::GetBool(JS_OPTIONS_DOT_STR "shared_memory");
+
+#ifdef DEBUG
+    sExtraWarningsForSystemJS = Preferences::GetBool(JS_OPTIONS_DOT_STR "strict.debug");
+#endif
+
+#ifdef JS_GC_ZEAL
+    int32_t zeal = Preferences::GetInt(JS_OPTIONS_DOT_STR "gczeal", -1);
+    int32_t zeal_frequency =
+        Preferences::GetInt(JS_OPTIONS_DOT_STR "gczeal.frequency",
+                            JS_DEFAULT_ZEAL_FREQ);
+    if (zeal >= 0) {
+        JS_SetGCZeal(cx, (uint8_t)zeal, zeal_frequency);
+    }
+#endif // JS_GC_ZEAL
+
+    JS::ContextOptionsRef(cx).setBaseline(useBaseline)
+                             .setIon(useIon)
+                             .setAsmJS(useAsmJS)
+                             .setWasm(useWasm)
+                             .setWasmAlwaysBaseline(useWasmBaseline)
+                             .setThrowOnAsmJSValidationFailure(throwOnAsmJSValidationFailure)
+                             .setNativeRegExp(useNativeRegExp)
+                             .setAsyncStack(useAsyncStack)
+                             .setThrowOnDebuggeeWouldRun(throwOnDebuggeeWouldRun)
+                             .setDumpStackOnDebuggeeWouldRun(dumpStackOnDebuggeeWouldRun)
+                             .setWerror(werror)
+                             .setExtraWarnings(extraWarnings);
+
+    JS_SetParallelParsingEnabled(cx, parallelParsing);
+    JS_SetOffthreadIonCompilationEnabled(cx, offthreadIonCompilation);
+    JS_SetGlobalJitCompilerOption(cx, JSJITCOMPILER_BASELINE_WARMUP_TRIGGER,
+                                  useBaselineEager ? 0 : -1);
+    JS_SetGlobalJitCompilerOption(cx, JSJITCOMPILER_ION_WARMUP_TRIGGER,
+                                  useIonEager ? 0 : -1);
+}
+
+XPCJSContext::~XPCJSContext()
+{
+    // Elsewhere we abort immediately if XPCJSContext initialization fails.
+    // Therefore the context must be non-null.
+    MOZ_ASSERT(MaybeContext());
+
+    // This destructor runs before ~CycleCollectedJSContext, which does the
+    // actual JS_DestroyContext() call. But destroying the context triggers
+    // one final GC, which can call back into the context with various
+    // callbacks if we aren't careful. Null out the relevant callbacks.
+    js::SetActivityCallback(Context(), nullptr, nullptr);
+    JS_RemoveFinalizeCallback(Context(), FinalizeCallback);
+    JS_RemoveWeakPointerZoneGroupCallback(Context(), WeakPointerZoneGroupCallback);
+    JS_RemoveWeakPointerCompartmentCallback(Context(), WeakPointerCompartmentCallback);
+
+    // Clear any pending exception.  It might be an XPCWrappedJS, and if we try
+    // to destroy it later we will crash.
+    SetPendingException(nullptr);
+
+    JS::SetGCSliceCallback(Context(), mPrevGCSliceCallback);
+
+    xpc_DelocalizeContext(Context());
+
+    if (mWatchdogManager->GetWatchdog())
+        mWatchdogManager->StopWatchdog();
+
+    if (mCallContext)
+        mCallContext->SystemIsBeingShutDown();
+
+    auto rtPrivate = static_cast<PerThreadAtomCache*>(JS_GetContextPrivate(Context()));
+    delete rtPrivate;
+    JS_SetContextPrivate(Context(), nullptr);
+
+    // clean up and destroy maps...
+    mWrappedJSMap->ShutdownMarker();
+    delete mWrappedJSMap;
+    mWrappedJSMap = nullptr;
+
+    delete mWrappedJSClassMap;
+    mWrappedJSClassMap = nullptr;
+
+    delete mIID2NativeInterfaceMap;
+    mIID2NativeInterfaceMap = nullptr;
+
+    delete mClassInfo2NativeSetMap;
+    mClassInfo2NativeSetMap = nullptr;
+
+    delete mNativeSetMap;
+    mNativeSetMap = nullptr;
+
+    delete mThisTranslatorMap;
+    mThisTranslatorMap = nullptr;
+
+    delete mDyingWrappedNativeProtoMap;
+    mDyingWrappedNativeProtoMap = nullptr;
+
+#ifdef MOZ_ENABLE_PROFILER_SPS
+    // Tell the profiler that the context is gone
+    if (PseudoStack* stack = mozilla_get_pseudo_stack())
+        stack->sampleContext(nullptr);
+#endif
+
+    Preferences::UnregisterCallback(ReloadPrefsCallback, JS_OPTIONS_DOT_STR, this);
+}
+
+// If |*anonymizeID| is non-zero and this is a user compartment, the name will
+// be anonymized.
+static void
+GetCompartmentName(JSCompartment* c, nsCString& name, int* anonymizeID,
+                   bool replaceSlashes)
+{
+    if (js::IsAtomsCompartment(c)) {
+        name.AssignLiteral("atoms");
+    } else if (*anonymizeID && !js::IsSystemCompartment(c)) {
+        name.AppendPrintf("<anonymized-%d>", *anonymizeID);
+        *anonymizeID += 1;
+    } else if (JSPrincipals* principals = JS_GetCompartmentPrincipals(c)) {
+        nsresult rv = nsJSPrincipals::get(principals)->GetScriptLocation(name);
+        if (NS_FAILED(rv)) {
+            name.AssignLiteral("(unknown)");
+        }
+
+        // If the compartment's location (name) differs from the principal's
+        // script location, append the compartment's location to allow
+        // differentiation of multiple compartments owned by the same principal
+        // (e.g. components owned by the system or null principal).
+        CompartmentPrivate* compartmentPrivate = CompartmentPrivate::Get(c);
+        if (compartmentPrivate) {
+            const nsACString& location = compartmentPrivate->GetLocation();
+            if (!location.IsEmpty() && !location.Equals(name)) {
+                name.AppendLiteral(", ");
+                name.Append(location);
+            }
+        }
+
+        if (*anonymizeID) {
+            // We might have a file:// URL that includes a path from the local
+            // filesystem, which should be omitted if we're anonymizing.
+            static const char* filePrefix = "file://";
+            int filePos = name.Find(filePrefix);
+            if (filePos >= 0) {
+                int pathPos = filePos + strlen(filePrefix);
+                int lastSlashPos = -1;
+                for (int i = pathPos; i < int(name.Length()); i++) {
+                    if (name[i] == '/' || name[i] == '\\') {
+                        lastSlashPos = i;
+                    }
+                }
+                if (lastSlashPos != -1) {
+                    name.ReplaceASCII(pathPos, lastSlashPos - pathPos,
+                                      "<anonymized>");
+                } else {
+                    // Something went wrong. Anonymize the entire path to be
+                    // safe.
+                    name.Truncate(pathPos);
+                    name += "<anonymized?!>";
+                }
+            }
+
+            // We might have a location like this:
+            //   inProcessTabChildGlobal?ownedBy=http://www.example.com/
+            // The owner should be omitted if it's not a chrome: URI and we're
+            // anonymizing.
+            static const char* ownedByPrefix =
+                "inProcessTabChildGlobal?ownedBy=";
+            int ownedByPos = name.Find(ownedByPrefix);
+            if (ownedByPos >= 0) {
+                const char* chrome = "chrome:";
+                int ownerPos = ownedByPos + strlen(ownedByPrefix);
+                const nsDependentCSubstring& ownerFirstPart =
+                    Substring(name, ownerPos, strlen(chrome));
+                if (!ownerFirstPart.EqualsASCII(chrome)) {
+                    name.Truncate(ownerPos);
+                    name += "<anonymized>";
+                }
+            }
+        }
+
+        // A hack: replace forward slashes with '\\' so they aren't
+        // treated as path separators.  Users of the reporters
+        // (such as about:memory) have to undo this change.
+        if (replaceSlashes)
+            name.ReplaceChar('/', '\\');
+    } else {
+        name.AssignLiteral("null-principal");
+    }
+}
+
+extern void
+xpc::GetCurrentCompartmentName(JSContext* cx, nsCString& name)
+{
+    RootedObject global(cx, JS::CurrentGlobalOrNull(cx));
+    if (!global) {
+        name.AssignLiteral("no global");
+        return;
+    }
+
+    JSCompartment* compartment = GetObjectCompartment(global);
+    int anonymizeID = 0;
+    GetCompartmentName(compartment, name, &anonymizeID, false);
+}
+
+void
+xpc::AddGCCallback(xpcGCCallback cb)
+{
+    XPCJSContext::Get()->AddGCCallback(cb);
+}
+
+void
+xpc::RemoveGCCallback(xpcGCCallback cb)
+{
+    XPCJSContext::Get()->RemoveGCCallback(cb);
+}
+
+static int64_t
+JSMainRuntimeGCHeapDistinguishedAmount()
+{
+    JSContext* cx = danger::GetJSContext();
+    return int64_t(JS_GetGCParameter(cx, JSGC_TOTAL_CHUNKS)) *
+           js::gc::ChunkSize;
+}
+
+static int64_t
+JSMainRuntimeTemporaryPeakDistinguishedAmount()
+{
+    JSContext* cx = danger::GetJSContext();
+    return JS::PeakSizeOfTemporary(cx);
+}
+
+static int64_t
+JSMainRuntimeCompartmentsSystemDistinguishedAmount()
+{
+    JSContext* cx = danger::GetJSContext();
+    return JS::SystemCompartmentCount(cx);
+}
+
+static int64_t
+JSMainRuntimeCompartmentsUserDistinguishedAmount()
+{
+    JSContext* cx = nsXPConnect::GetContextInstance()->Context();
+    return JS::UserCompartmentCount(cx);
+}
+
+class JSMainRuntimeTemporaryPeakReporter final : public nsIMemoryReporter
+{
+    ~JSMainRuntimeTemporaryPeakReporter() {}
+
+  public:
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
+                              nsISupports* aData, bool aAnonymize) override
+    {
+        MOZ_COLLECT_REPORT(
+            "js-main-runtime-temporary-peak", KIND_OTHER, UNITS_BYTES,
+            JSMainRuntimeTemporaryPeakDistinguishedAmount(),
+            "Peak transient data size in the main JSRuntime (the current size "
+            "of which is reported as "
+            "'explicit/js-non-window/runtime/temporary').");
+
+        return NS_OK;
+    }
+};
+
+NS_IMPL_ISUPPORTS(JSMainRuntimeTemporaryPeakReporter, nsIMemoryReporter)
+
+// The REPORT* macros do an unconditional report.  The ZCREPORT* macros are for
+// compartments and zones; they aggregate any entries smaller than
+// SUNDRIES_THRESHOLD into the "sundries/gc-heap" and "sundries/malloc-heap"
+// entries for the compartment.
+
+#define SUNDRIES_THRESHOLD js::MemoryReportingSundriesThreshold()
+
+#define REPORT(_path, _kind, _units, _amount, _desc) \
+    handleReport->Callback(EmptyCString(), _path, \
+                           nsIMemoryReporter::_kind, \
+                           nsIMemoryReporter::_units, _amount, \
+                           NS_LITERAL_CSTRING(_desc), data); \
+
+#define REPORT_BYTES(_path, _kind, _amount, _desc) \
+    REPORT(_path, _kind, UNITS_BYTES, _amount, _desc);
+
+#define REPORT_GC_BYTES(_path, _amount, _desc) \
+    do { \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        handleReport->Callback(EmptyCString(), _path, \
+                               nsIMemoryReporter::KIND_NONHEAP, \
+                               nsIMemoryReporter::UNITS_BYTES, amount, \
+                               NS_LITERAL_CSTRING(_desc), data); \
+        gcTotal += amount; \
+    } while (0)
+
+// Report compartment/zone non-GC (KIND_HEAP) bytes.
+#define ZCREPORT_BYTES(_path, _amount, _desc) \
+    do { \
+        /* Assign _descLiteral plus "" into a char* to prove that it's */ \
+        /* actually a literal. */ \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        if (amount >= SUNDRIES_THRESHOLD) { \
+            handleReport->Callback(EmptyCString(), _path, \
+                                   nsIMemoryReporter::KIND_HEAP, \
+                                   nsIMemoryReporter::UNITS_BYTES, amount, \
+                                   NS_LITERAL_CSTRING(_desc), data); \
+        } else { \
+            sundriesMallocHeap += amount; \
+        } \
+    } while (0)
+
+// Report compartment/zone GC bytes.
+#define ZCREPORT_GC_BYTES(_path, _amount, _desc) \
+    do { \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        if (amount >= SUNDRIES_THRESHOLD) { \
+            handleReport->Callback(EmptyCString(), _path, \
+                                   nsIMemoryReporter::KIND_NONHEAP, \
+                                   nsIMemoryReporter::UNITS_BYTES, amount, \
+                                   NS_LITERAL_CSTRING(_desc), data); \
+            gcTotal += amount; \
+        } else { \
+            sundriesGCHeap += amount; \
+        } \
+    } while (0)
+
+// Report runtime bytes.
+#define RREPORT_BYTES(_path, _kind, _amount, _desc) \
+    do { \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        handleReport->Callback(EmptyCString(), _path, \
+                               nsIMemoryReporter::_kind, \
+                               nsIMemoryReporter::UNITS_BYTES, amount, \
+                               NS_LITERAL_CSTRING(_desc), data); \
+        rtTotal += amount; \
+    } while (0)
+
+// Report GC thing bytes.
+#define MREPORT_BYTES(_path, _kind, _amount, _desc) \
+    do { \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        handleReport->Callback(EmptyCString(), _path, \
+                               nsIMemoryReporter::_kind, \
+                               nsIMemoryReporter::UNITS_BYTES, amount, \
+                               NS_LITERAL_CSTRING(_desc), data); \
+        gcThingTotal += amount; \
+    } while (0)
+
+MOZ_DEFINE_MALLOC_SIZE_OF(JSMallocSizeOf)
+
+namespace xpc {
+
+static void
+ReportZoneStats(const JS::ZoneStats& zStats,
+                const xpc::ZoneStatsExtras& extras,
+                nsIHandleReportCallback* handleReport,
+                nsISupports* data,
+                bool anonymize,
+                size_t* gcTotalOut = nullptr)
+{
+    const nsCString& pathPrefix = extras.pathPrefix;
+    size_t gcTotal = 0, sundriesGCHeap = 0, sundriesMallocHeap = 0;
+
+    MOZ_ASSERT(!gcTotalOut == zStats.isTotals);
+
+    ZCREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("symbols/gc-heap"),
+        zStats.symbolsGCHeap,
+        "Symbols.");
+
+    ZCREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("gc-heap-arena-admin"),
+        zStats.gcHeapArenaAdmin,
+        "Bookkeeping information and alignment padding within GC arenas.");
+
+    ZCREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("unused-gc-things"),
+        zStats.unusedGCThings.totalSize(),
+        "Unused GC thing cells within non-empty arenas.");
+
+    ZCREPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("unique-id-map"),
+        zStats.uniqueIdMap,
+        "Address-independent cell identities.");
+
+    ZCREPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("shape-tables"),
+        zStats.shapeTables,
+        "Tables storing shape information.");
+
+    ZCREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("lazy-scripts/gc-heap"),
+        zStats.lazyScriptsGCHeap,
+        "Scripts that haven't executed yet.");
+
+    ZCREPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("lazy-scripts/malloc-heap"),
+        zStats.lazyScriptsMallocHeap,
+        "Lazy script tables containing closed-over bindings or inner functions.");
+
+    ZCREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("jit-codes-gc-heap"),
+        zStats.jitCodesGCHeap,
+        "References to executable code pools used by the JITs.");
+
+    ZCREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("object-groups/gc-heap"),
+        zStats.objectGroupsGCHeap,
+        "Classification and type inference information about objects.");
+
+    ZCREPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("object-groups/malloc-heap"),
+        zStats.objectGroupsMallocHeap,
+        "Object group addenda.");
+
+    ZCREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("scopes/gc-heap"),
+        zStats.scopesGCHeap,
+        "Scope information for scripts.");
+
+    ZCREPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("scopes/malloc-heap"),
+        zStats.scopesMallocHeap,
+        "Arrays of binding names and other binding-related data.");
+
+    ZCREPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("type-pool"),
+        zStats.typePool,
+        "Type sets and related data.");
+
+    ZCREPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("baseline/optimized-stubs"),
+        zStats.baselineStubsOptimized,
+        "The Baseline JIT's optimized IC stubs (excluding code).");
+
+    size_t stringsNotableAboutMemoryGCHeap = 0;
+    size_t stringsNotableAboutMemoryMallocHeap = 0;
+
+    #define MAYBE_INLINE \
+        "The characters may be inline or on the malloc heap."
+    #define MAYBE_OVERALLOCATED \
+        "Sometimes over-allocated to simplify string concatenation."
+
+    for (size_t i = 0; i < zStats.notableStrings.length(); i++) {
+        const JS::NotableStringInfo& info = zStats.notableStrings[i];
+
+        MOZ_ASSERT(!zStats.isTotals);
+
+        // We don't do notable string detection when anonymizing, because
+        // there's a good chance its for crash submission, and the memory
+        // required for notable string detection is high.
+        MOZ_ASSERT(!anonymize);
+
+        nsDependentCString notableString(info.buffer);
+
+        // Viewing about:memory generates many notable strings which contain
+        // "string(length=".  If we report these as notable, then we'll create
+        // even more notable strings the next time we open about:memory (unless
+        // there's a GC in the meantime), and so on ad infinitum.
+        //
+        // To avoid cluttering up about:memory like this, we stick notable
+        // strings which contain "string(length=" into their own bucket.
+#       define STRING_LENGTH "string(length="
+        if (FindInReadable(NS_LITERAL_CSTRING(STRING_LENGTH), notableString)) {
+            stringsNotableAboutMemoryGCHeap += info.gcHeapLatin1;
+            stringsNotableAboutMemoryGCHeap += info.gcHeapTwoByte;
+            stringsNotableAboutMemoryMallocHeap += info.mallocHeapLatin1;
+            stringsNotableAboutMemoryMallocHeap += info.mallocHeapTwoByte;
+            continue;
+        }
+
+        // Escape / to \ before we put notableString into the memory reporter
+        // path, because we don't want any forward slashes in the string to
+        // count as path separators.
+        nsCString escapedString(notableString);
+        escapedString.ReplaceSubstring("/", "\\");
+
+        bool truncated = notableString.Length() < info.length;
+
+        nsCString path = pathPrefix +
+            nsPrintfCString("strings/" STRING_LENGTH "%d, copies=%d, \"%s\"%s)/",
+                            info.length, info.numCopies, escapedString.get(),
+                            truncated ? " (truncated)" : "");
+
+        if (info.gcHeapLatin1 > 0) {
+            REPORT_GC_BYTES(path + NS_LITERAL_CSTRING("gc-heap/latin1"),
+                info.gcHeapLatin1,
+                "Latin1 strings. " MAYBE_INLINE);
+        }
+
+        if (info.gcHeapTwoByte > 0) {
+            REPORT_GC_BYTES(path + NS_LITERAL_CSTRING("gc-heap/two-byte"),
+                info.gcHeapTwoByte,
+                "TwoByte strings. " MAYBE_INLINE);
+        }
+
+        if (info.mallocHeapLatin1 > 0) {
+            REPORT_BYTES(path + NS_LITERAL_CSTRING("malloc-heap/latin1"),
+                KIND_HEAP, info.mallocHeapLatin1,
+                "Non-inline Latin1 string characters. " MAYBE_OVERALLOCATED);
+        }
+
+        if (info.mallocHeapTwoByte > 0) {
+            REPORT_BYTES(path + NS_LITERAL_CSTRING("malloc-heap/two-byte"),
+                KIND_HEAP, info.mallocHeapTwoByte,
+                "Non-inline TwoByte string characters. " MAYBE_OVERALLOCATED);
+        }
+    }
+
+    nsCString nonNotablePath = pathPrefix;
+    nonNotablePath += (zStats.isTotals || anonymize)
+                    ? NS_LITERAL_CSTRING("strings/")
+                    : NS_LITERAL_CSTRING("strings/string(<non-notable strings>)/");
+
+    if (zStats.stringInfo.gcHeapLatin1 > 0) {
+        REPORT_GC_BYTES(nonNotablePath + NS_LITERAL_CSTRING("gc-heap/latin1"),
+            zStats.stringInfo.gcHeapLatin1,
+            "Latin1 strings. " MAYBE_INLINE);
+    }
+
+    if (zStats.stringInfo.gcHeapTwoByte > 0) {
+        REPORT_GC_BYTES(nonNotablePath + NS_LITERAL_CSTRING("gc-heap/two-byte"),
+            zStats.stringInfo.gcHeapTwoByte,
+            "TwoByte strings. " MAYBE_INLINE);
+    }
+
+    if (zStats.stringInfo.mallocHeapLatin1 > 0) {
+        REPORT_BYTES(nonNotablePath + NS_LITERAL_CSTRING("malloc-heap/latin1"),
+            KIND_HEAP, zStats.stringInfo.mallocHeapLatin1,
+            "Non-inline Latin1 string characters. " MAYBE_OVERALLOCATED);
+    }
+
+    if (zStats.stringInfo.mallocHeapTwoByte > 0) {
+        REPORT_BYTES(nonNotablePath + NS_LITERAL_CSTRING("malloc-heap/two-byte"),
+            KIND_HEAP, zStats.stringInfo.mallocHeapTwoByte,
+            "Non-inline TwoByte string characters. " MAYBE_OVERALLOCATED);
+    }
+
+    if (stringsNotableAboutMemoryGCHeap > 0) {
+        MOZ_ASSERT(!zStats.isTotals);
+        REPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("strings/string(<about-memory>)/gc-heap"),
+            stringsNotableAboutMemoryGCHeap,
+            "Strings that contain the characters '" STRING_LENGTH "', which "
+            "are probably from about:memory itself." MAYBE_INLINE
+            " We filter them out rather than display them, because displaying "
+            "them would create even more such strings every time about:memory "
+            "is refreshed.");
+    }
+
+    if (stringsNotableAboutMemoryMallocHeap > 0) {
+        MOZ_ASSERT(!zStats.isTotals);
+        REPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("strings/string(<about-memory>)/malloc-heap"),
+            KIND_HEAP, stringsNotableAboutMemoryMallocHeap,
+            "Non-inline string characters of strings that contain the "
+            "characters '" STRING_LENGTH "', which are probably from "
+            "about:memory itself. " MAYBE_OVERALLOCATED
+            " We filter them out rather than display them, because displaying "
+            "them would create even more such strings every time about:memory "
+            "is refreshed.");
+    }
+
+    const JS::ShapeInfo& shapeInfo = zStats.shapeInfo;
+    if (shapeInfo.shapesGCHeapTree > 0) {
+        REPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("shapes/gc-heap/tree"),
+            shapeInfo.shapesGCHeapTree,
+        "Shapes in a property tree.");
+    }
+
+    if (shapeInfo.shapesGCHeapDict > 0) {
+        REPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("shapes/gc-heap/dict"),
+            shapeInfo.shapesGCHeapDict,
+        "Shapes in dictionary mode.");
+    }
+
+    if (shapeInfo.shapesGCHeapBase > 0) {
+        REPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("shapes/gc-heap/base"),
+            shapeInfo.shapesGCHeapBase,
+            "Base shapes, which collate data common to many shapes.");
+    }
+
+    if (shapeInfo.shapesMallocHeapTreeTables > 0) {
+        REPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("shapes/malloc-heap/tree-tables"),
+            KIND_HEAP, shapeInfo.shapesMallocHeapTreeTables,
+            "Property tables of shapes in a property tree.");
+    }
+
+    if (shapeInfo.shapesMallocHeapDictTables > 0) {
+        REPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("shapes/malloc-heap/dict-tables"),
+            KIND_HEAP, shapeInfo.shapesMallocHeapDictTables,
+            "Property tables of shapes in dictionary mode.");
+    }
+
+    if (shapeInfo.shapesMallocHeapTreeKids > 0) {
+        REPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("shapes/malloc-heap/tree-kids"),
+            KIND_HEAP, shapeInfo.shapesMallocHeapTreeKids,
+            "Kid hashes of shapes in a property tree.");
+    }
+
+    if (sundriesGCHeap > 0) {
+        // We deliberately don't use ZCREPORT_GC_BYTES here.
+        REPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("sundries/gc-heap"),
+            sundriesGCHeap,
+            "The sum of all 'gc-heap' measurements that are too small to be "
+            "worth showing individually.");
+    }
+
+    if (sundriesMallocHeap > 0) {
+        // We deliberately don't use ZCREPORT_BYTES here.
+        REPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("sundries/malloc-heap"),
+            KIND_HEAP, sundriesMallocHeap,
+            "The sum of all 'malloc-heap' measurements that are too small to "
+            "be worth showing individually.");
+    }
+
+    if (gcTotalOut)
+        *gcTotalOut += gcTotal;
+
+#   undef STRING_LENGTH
+}
+
+static void
+ReportClassStats(const ClassInfo& classInfo, const nsACString& path,
+                 nsIHandleReportCallback* handleReport,
+                 nsISupports* data, size_t& gcTotal)
+{
+    // We deliberately don't use ZCREPORT_BYTES, so that these per-class values
+    // don't go into sundries.
+
+    if (classInfo.objectsGCHeap > 0) {
+        REPORT_GC_BYTES(path + NS_LITERAL_CSTRING("objects/gc-heap"),
+            classInfo.objectsGCHeap,
+            "Objects, including fixed slots.");
+    }
+
+    if (classInfo.objectsMallocHeapSlots > 0) {
+        REPORT_BYTES(path + NS_LITERAL_CSTRING("objects/malloc-heap/slots"),
+            KIND_HEAP, classInfo.objectsMallocHeapSlots,
+            "Non-fixed object slots.");
+    }
+
+    if (classInfo.objectsMallocHeapElementsNormal > 0) {
+        REPORT_BYTES(path + NS_LITERAL_CSTRING("objects/malloc-heap/elements/normal"),
+            KIND_HEAP, classInfo.objectsMallocHeapElementsNormal,
+            "Normal (non-wasm) indexed elements.");
+    }
+
+    if (classInfo.objectsMallocHeapElementsAsmJS > 0) {
+        REPORT_BYTES(path + NS_LITERAL_CSTRING("objects/malloc-heap/elements/asm.js"),
+            KIND_HEAP, classInfo.objectsMallocHeapElementsAsmJS,
+            "asm.js array buffer elements allocated in the malloc heap.");
+    }
+
+    if (classInfo.objectsMallocHeapMisc > 0) {
+        REPORT_BYTES(path + NS_LITERAL_CSTRING("objects/malloc-heap/misc"),
+            KIND_HEAP, classInfo.objectsMallocHeapMisc,
+            "Miscellaneous object data.");
+    }
+
+    if (classInfo.objectsNonHeapElementsNormal > 0) {
+        REPORT_BYTES(path + NS_LITERAL_CSTRING("objects/non-heap/elements/normal"),
+            KIND_NONHEAP, classInfo.objectsNonHeapElementsNormal,
+            "Memory-mapped non-shared array buffer elements.");
+    }
+
+    if (classInfo.objectsNonHeapElementsShared > 0) {
+        REPORT_BYTES(path + NS_LITERAL_CSTRING("objects/non-heap/elements/shared"),
+            KIND_NONHEAP, classInfo.objectsNonHeapElementsShared,
+            "Memory-mapped shared array buffer elements. These elements are "
+            "shared between one or more runtimes; the reported size is divided "
+            "by the buffer's refcount.");
+    }
+
+    // WebAssembly memories are always non-heap-allocated (mmap). We never put
+    // these under sundries, because (a) in practice they're almost always
+    // larger than the sundries threshold, and (b) we'd need a third category of
+    // sundries ("non-heap"), which would be a pain.
+    if (classInfo.objectsNonHeapElementsWasm > 0) {
+        REPORT_BYTES(path + NS_LITERAL_CSTRING("objects/non-heap/elements/wasm"),
+            KIND_NONHEAP, classInfo.objectsNonHeapElementsWasm,
+            "wasm/asm.js array buffer elements allocated outside both the "
+            "malloc heap and the GC heap.");
+    }
+
+    if (classInfo.objectsNonHeapCodeWasm > 0) {
+        REPORT_BYTES(path + NS_LITERAL_CSTRING("objects/non-heap/code/wasm"),
+            KIND_NONHEAP, classInfo.objectsNonHeapCodeWasm,
+            "AOT-compiled wasm/asm.js code.");
+    }
+
+    // Although wasm guard pages aren't committed in memory they can be very
+    // large and contribute greatly to vsize and so are worth reporting.
+    if (classInfo.wasmGuardPages > 0) {
+        REPORT_BYTES(NS_LITERAL_CSTRING("wasm-guard-pages"),
+            KIND_OTHER, classInfo.wasmGuardPages,
+            "Guard pages mapped after the end of wasm memories, reserved for "
+            "optimization tricks, but not committed and thus never contributing"
+            " to RSS, only vsize.");
+    }
+}
+
+static void
+ReportCompartmentStats(const JS::CompartmentStats& cStats,
+                       const xpc::CompartmentStatsExtras& extras,
+                       amIAddonManager* addonManager,
+                       nsIHandleReportCallback* handleReport,
+                       nsISupports* data, size_t* gcTotalOut = nullptr)
+{
+    static const nsDependentCString addonPrefix("explicit/add-ons/");
+
+    size_t gcTotal = 0, sundriesGCHeap = 0, sundriesMallocHeap = 0;
+    nsAutoCString cJSPathPrefix(extras.jsPathPrefix);
+    nsAutoCString cDOMPathPrefix(extras.domPathPrefix);
+
+    MOZ_ASSERT(!gcTotalOut == cStats.isTotals);
+
+    // Only attempt to prefix if we got a location and the path wasn't already
+    // prefixed.
+    if (extras.location && addonManager &&
+        cJSPathPrefix.Find(addonPrefix, false, 0, 0) != 0) {
+        nsAutoCString addonId;
+        bool ok;
+        if (NS_SUCCEEDED(addonManager->MapURIToAddonID(extras.location,
+                                                        addonId, &ok))
+            && ok) {
+            // Insert the add-on id as "add-ons/@id@/" after "explicit/" to
+            // aggregate add-on compartments.
+            static const size_t explicitLength = strlen("explicit/");
+            addonId.Insert(NS_LITERAL_CSTRING("add-ons/"), 0);
+            addonId += "/";
+            cJSPathPrefix.Insert(addonId, explicitLength);
+            cDOMPathPrefix.Insert(addonId, explicitLength);
+        }
+    }
+
+    nsCString nonNotablePath = cJSPathPrefix;
+    nonNotablePath += cStats.isTotals
+                    ? NS_LITERAL_CSTRING("classes/")
+                    : NS_LITERAL_CSTRING("classes/class(<non-notable classes>)/");
+
+    ReportClassStats(cStats.classInfo, nonNotablePath, handleReport, data,
+                     gcTotal);
+
+    for (size_t i = 0; i < cStats.notableClasses.length(); i++) {
+        MOZ_ASSERT(!cStats.isTotals);
+        const JS::NotableClassInfo& classInfo = cStats.notableClasses[i];
+
+        nsCString classPath = cJSPathPrefix +
+            nsPrintfCString("classes/class(%s)/", classInfo.className_);
+
+        ReportClassStats(classInfo, classPath, handleReport, data, gcTotal);
+    }
+
+    // Note that we use cDOMPathPrefix here.  This is because we measure orphan
+    // DOM nodes in the JS reporter, but we want to report them in a "dom"
+    // sub-tree rather than a "js" sub-tree.
+    ZCREPORT_BYTES(cDOMPathPrefix + NS_LITERAL_CSTRING("orphan-nodes"),
+        cStats.objectsPrivate,
+        "Orphan DOM nodes, i.e. those that are only reachable from JavaScript "
+        "objects.");
+
+    ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("scripts/gc-heap"),
+        cStats.scriptsGCHeap,
+        "JSScript instances. There is one per user-defined function in a "
+        "script, and one for the top-level code in a script.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("scripts/malloc-heap/data"),
+        cStats.scriptsMallocHeapData,
+        "Various variable-length tables in JSScripts.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("baseline/data"),
+        cStats.baselineData,
+        "The Baseline JIT's compilation data (BaselineScripts).");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("baseline/fallback-stubs"),
+        cStats.baselineStubsFallback,
+        "The Baseline JIT's fallback IC stubs (excluding code).");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("ion-data"),
+        cStats.ionData,
+        "The IonMonkey JIT's compilation data (IonScripts).");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("type-inference/type-scripts"),
+        cStats.typeInferenceTypeScripts,
+        "Type sets associated with scripts.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("type-inference/allocation-site-tables"),
+        cStats.typeInferenceAllocationSiteTables,
+        "Tables of type objects associated with allocation sites.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("type-inference/array-type-tables"),
+        cStats.typeInferenceArrayTypeTables,
+        "Tables of type objects associated with array literals.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("type-inference/object-type-tables"),
+        cStats.typeInferenceObjectTypeTables,
+        "Tables of type objects associated with object literals.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("compartment-object"),
+        cStats.compartmentObject,
+        "The JSCompartment object itself.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("compartment-tables"),
+        cStats.compartmentTables,
+        "Compartment-wide tables storing object group information and wasm instances.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("inner-views"),
+        cStats.innerViewsTable,
+        "The table for array buffer inner views.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("lazy-array-buffers"),
+        cStats.lazyArrayBuffersTable,
+        "The table for typed object lazy array buffers.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("object-metadata"),
+        cStats.objectMetadataTable,
+        "The table used by debugging tools for tracking object metadata");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("cross-compartment-wrapper-table"),
+        cStats.crossCompartmentWrappersTable,
+        "The cross-compartment wrapper table.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("regexp-compartment"),
+        cStats.regexpCompartment,
+        "The regexp compartment and regexp data.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("saved-stacks-set"),
+        cStats.savedStacksSet,
+        "The saved stacks set.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("non-syntactic-lexical-scopes-table"),
+        cStats.nonSyntacticLexicalScopesTable,
+        "The non-syntactic lexical scopes table.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("jit-compartment"),
+        cStats.jitCompartment,
+        "The JIT compartment.");
+
+    ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("private-data"),
+        cStats.privateData,
+        "Extra data attached to the compartment by XPConnect, including "
+        "its wrapped-js.");
+
+    if (sundriesGCHeap > 0) {
+        // We deliberately don't use ZCREPORT_GC_BYTES here.
+        REPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("sundries/gc-heap"),
+            sundriesGCHeap,
+            "The sum of all 'gc-heap' measurements that are too small to be "
+            "worth showing individually.");
+    }
+
+    if (sundriesMallocHeap > 0) {
+        // We deliberately don't use ZCREPORT_BYTES here.
+        REPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("sundries/malloc-heap"),
+            KIND_HEAP, sundriesMallocHeap,
+            "The sum of all 'malloc-heap' measurements that are too small to "
+            "be worth showing individually.");
+    }
+
+    if (gcTotalOut)
+        *gcTotalOut += gcTotal;
+}
+
+static void
+ReportScriptSourceStats(const ScriptSourceInfo& scriptSourceInfo,
+                        const nsACString& path,
+                        nsIHandleReportCallback* handleReport,
+                        nsISupports* data, size_t& rtTotal)
+{
+    if (scriptSourceInfo.misc > 0) {
+        RREPORT_BYTES(path + NS_LITERAL_CSTRING("misc"),
+            KIND_HEAP, scriptSourceInfo.misc,
+            "Miscellaneous data relating to JavaScript source code.");
+    }
+}
+
+static void
+ReportJSRuntimeExplicitTreeStats(const JS::RuntimeStats& rtStats,
+                                 const nsACString& rtPath,
+                                 amIAddonManager* addonManager,
+                                 nsIHandleReportCallback* handleReport,
+                                 nsISupports* data,
+                                 bool anonymize,
+                                 size_t* rtTotalOut)
+{
+    size_t gcTotal = 0;
+
+    for (size_t i = 0; i < rtStats.zoneStatsVector.length(); i++) {
+        const JS::ZoneStats& zStats = rtStats.zoneStatsVector[i];
+        const xpc::ZoneStatsExtras* extras =
+          static_cast<const xpc::ZoneStatsExtras*>(zStats.extra);
+        ReportZoneStats(zStats, *extras, handleReport, data, anonymize,
+                        &gcTotal);
+    }
+
+    for (size_t i = 0; i < rtStats.compartmentStatsVector.length(); i++) {
+        const JS::CompartmentStats& cStats = rtStats.compartmentStatsVector[i];
+        const xpc::CompartmentStatsExtras* extras =
+            static_cast<const xpc::CompartmentStatsExtras*>(cStats.extra);
+
+        ReportCompartmentStats(cStats, *extras, addonManager, handleReport,
+                               data, &gcTotal);
+    }
+
+    // Report the rtStats.runtime numbers under "runtime/", and compute their
+    // total for later.
+
+    size_t rtTotal = 0;
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/runtime-object"),
+        KIND_HEAP, rtStats.runtime.object,
+        "The JSRuntime object.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/atoms-table"),
+        KIND_HEAP, rtStats.runtime.atomsTable,
+        "The atoms table.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/contexts"),
+        KIND_HEAP, rtStats.runtime.contexts,
+        "JSContext objects and structures that belong to them.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/temporary"),
+        KIND_HEAP, rtStats.runtime.temporary,
+        "Transient data (mostly parse nodes) held by the JSRuntime during "
+        "compilation.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/interpreter-stack"),
+        KIND_HEAP, rtStats.runtime.interpreterStack,
+        "JS interpreter frames.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/math-cache"),
+        KIND_HEAP, rtStats.runtime.mathCache,
+        "The math cache.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/shared-immutable-strings-cache"),
+        KIND_HEAP, rtStats.runtime.sharedImmutableStringsCache,
+        "Immutable strings (such as JS scripts' source text) shared across all JSRuntimes.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/shared-intl-data"),
+        KIND_HEAP, rtStats.runtime.sharedIntlData,
+        "Shared internationalization data.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/uncompressed-source-cache"),
+        KIND_HEAP, rtStats.runtime.uncompressedSourceCache,
+        "The uncompressed source code cache.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/script-data"),
+        KIND_HEAP, rtStats.runtime.scriptData,
+        "The table holding script data shared in the runtime.");
+
+    nsCString nonNotablePath =
+        rtPath + nsPrintfCString("runtime/script-sources/source(scripts=%d, <non-notable files>)/",
+                                 rtStats.runtime.scriptSourceInfo.numScripts);
+
+    ReportScriptSourceStats(rtStats.runtime.scriptSourceInfo,
+                            nonNotablePath, handleReport, data, rtTotal);
+
+    for (size_t i = 0; i < rtStats.runtime.notableScriptSources.length(); i++) {
+        const JS::NotableScriptSourceInfo& scriptSourceInfo =
+            rtStats.runtime.notableScriptSources[i];
+
+        // Escape / to \ before we put the filename into the memory reporter
+        // path, because we don't want any forward slashes in the string to
+        // count as path separators. Consumers of memory reporters (e.g.
+        // about:memory) will convert them back to / after doing path
+        // splitting.
+        nsCString escapedFilename;
+        if (anonymize) {
+            escapedFilename.AppendPrintf("<anonymized-source-%d>", int(i));
+        } else {
+            nsDependentCString filename(scriptSourceInfo.filename_);
+            escapedFilename.Append(filename);
+            escapedFilename.ReplaceSubstring("/", "\\");
+        }
+
+        nsCString notablePath = rtPath +
+            nsPrintfCString("runtime/script-sources/source(scripts=%d, %s)/",
+                            scriptSourceInfo.numScripts, escapedFilename.get());
+
+        ReportScriptSourceStats(scriptSourceInfo, notablePath,
+                                handleReport, data, rtTotal);
+    }
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/code/ion"),
+        KIND_NONHEAP, rtStats.runtime.code.ion,
+        "Code generated by the IonMonkey JIT.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/code/baseline"),
+        KIND_NONHEAP, rtStats.runtime.code.baseline,
+        "Code generated by the Baseline JIT.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/code/regexp"),
+        KIND_NONHEAP, rtStats.runtime.code.regexp,
+        "Code generated by the regexp JIT.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/code/other"),
+        KIND_NONHEAP, rtStats.runtime.code.other,
+        "Code generated by the JITs for wrappers and trampolines.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/code/unused"),
+        KIND_NONHEAP, rtStats.runtime.code.unused,
+        "Memory allocated by one of the JITs to hold code, but which is "
+        "currently unused.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/gc/marker"),
+        KIND_HEAP, rtStats.runtime.gc.marker,
+        "The GC mark stack and gray roots.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/gc/nursery-committed"),
+        KIND_NONHEAP, rtStats.runtime.gc.nurseryCommitted,
+        "Memory being used by the GC's nursery.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/gc/nursery-malloced-buffers"),
+        KIND_HEAP, rtStats.runtime.gc.nurseryMallocedBuffers,
+        "Out-of-line slots and elements belonging to objects in the nursery.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/gc/store-buffer/vals"),
+        KIND_HEAP, rtStats.runtime.gc.storeBufferVals,
+        "Values in the store buffer.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/gc/store-buffer/cells"),
+        KIND_HEAP, rtStats.runtime.gc.storeBufferCells,
+        "Cells in the store buffer.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/gc/store-buffer/slots"),
+        KIND_HEAP, rtStats.runtime.gc.storeBufferSlots,
+        "Slots in the store buffer.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/gc/store-buffer/whole-cells"),
+        KIND_HEAP, rtStats.runtime.gc.storeBufferWholeCells,
+        "Whole cells in the store buffer.");
+
+    RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/gc/store-buffer/generics"),
+        KIND_HEAP, rtStats.runtime.gc.storeBufferGenerics,
+        "Generic things in the store buffer.");
+
+    if (rtTotalOut)
+        *rtTotalOut = rtTotal;
+
+    // Report GC numbers that don't belong to a compartment.
+
+    // We don't want to report decommitted memory in "explicit", so we just
+    // change the leading "explicit/" to "decommitted/".
+    nsCString rtPath2(rtPath);
+    rtPath2.Replace(0, strlen("explicit"), NS_LITERAL_CSTRING("decommitted"));
+    REPORT_GC_BYTES(rtPath2 + NS_LITERAL_CSTRING("gc-heap/decommitted-arenas"),
+        rtStats.gcHeapDecommittedArenas,
+        "GC arenas in non-empty chunks that is decommitted, i.e. it takes up "
+        "address space but no physical memory or swap space.");
+
+    REPORT_GC_BYTES(rtPath + NS_LITERAL_CSTRING("gc-heap/unused-chunks"),
+        rtStats.gcHeapUnusedChunks,
+        "Empty GC chunks which will soon be released unless claimed for new "
+        "allocations.");
+
+    REPORT_GC_BYTES(rtPath + NS_LITERAL_CSTRING("gc-heap/unused-arenas"),
+        rtStats.gcHeapUnusedArenas,
+        "Empty GC arenas within non-empty chunks.");
+
+    REPORT_GC_BYTES(rtPath + NS_LITERAL_CSTRING("gc-heap/chunk-admin"),
+        rtStats.gcHeapChunkAdmin,
+        "Bookkeeping information within GC chunks.");
+
+    // gcTotal is the sum of everything we've reported for the GC heap.  It
+    // should equal rtStats.gcHeapChunkTotal.
+    MOZ_ASSERT(gcTotal == rtStats.gcHeapChunkTotal);
+}
+
+void
+ReportJSRuntimeExplicitTreeStats(const JS::RuntimeStats& rtStats,
+                                 const nsACString& rtPath,
+                                 nsIHandleReportCallback* handleReport,
+                                 nsISupports* data,
+                                 bool anonymize,
+                                 size_t* rtTotalOut)
+{
+    nsCOMPtr<amIAddonManager> am;
+    if (XRE_IsParentProcess()) {
+        // Only try to access the service from the main process.
+        am = do_GetService("@mozilla.org/addons/integration;1");
+    }
+    ReportJSRuntimeExplicitTreeStats(rtStats, rtPath, am.get(), handleReport,
+                                     data, anonymize, rtTotalOut);
+}
+
+
+} // namespace xpc
+
+class JSMainRuntimeCompartmentsReporter final : public nsIMemoryReporter
+{
+
+    ~JSMainRuntimeCompartmentsReporter() {}
+
+  public:
+    NS_DECL_ISUPPORTS
+
+    struct Data {
+        int anonymizeID;
+        js::Vector<nsCString, 0, js::SystemAllocPolicy> paths;
+    };
+
+    static void CompartmentCallback(JSContext* cx, void* vdata, JSCompartment* c) {
+        // silently ignore OOM errors
+        Data* data = static_cast<Data*>(vdata);
+        nsCString path;
+        GetCompartmentName(c, path, &data->anonymizeID, /* replaceSlashes = */ true);
+        path.Insert(js::IsSystemCompartment(c)
+                    ? NS_LITERAL_CSTRING("js-main-runtime-compartments/system/")
+                    : NS_LITERAL_CSTRING("js-main-runtime-compartments/user/"),
+                    0);
+        mozilla::Unused << data->paths.append(path);
+    }
+
+    NS_IMETHOD CollectReports(nsIHandleReportCallback* handleReport,
+                              nsISupports* data, bool anonymize) override
+    {
+        // First we collect the compartment paths.  Then we report them.  Doing
+        // the two steps interleaved is a bad idea, because calling
+        // |handleReport| from within CompartmentCallback() leads to all manner
+        // of assertions.
+
+        Data d;
+        d.anonymizeID = anonymize ? 1 : 0;
+        JS_IterateCompartments(nsXPConnect::GetContextInstance()->Context(),
+                               &d, CompartmentCallback);
+
+        for (size_t i = 0; i < d.paths.length(); i++)
+            REPORT(nsCString(d.paths[i]), KIND_OTHER, UNITS_COUNT, 1,
+                "A live compartment in the main JSRuntime.");
+
+        return NS_OK;
+    }
+};
+
+NS_IMPL_ISUPPORTS(JSMainRuntimeCompartmentsReporter, nsIMemoryReporter)
+
+MOZ_DEFINE_MALLOC_SIZE_OF(OrphanMallocSizeOf)
+
+namespace xpc {
+
+static size_t
+SizeOfTreeIncludingThis(nsINode* tree)
+{
+    size_t n = tree->SizeOfIncludingThis(OrphanMallocSizeOf);
+    for (nsIContent* child = tree->GetFirstChild(); child; child = child->GetNextNode(tree))
+        n += child->SizeOfIncludingThis(OrphanMallocSizeOf);
+
+    return n;
+}
+
+class OrphanReporter : public JS::ObjectPrivateVisitor
+{
+  public:
+    explicit OrphanReporter(GetISupportsFun aGetISupports)
+      : JS::ObjectPrivateVisitor(aGetISupports)
+    {
+    }
+
+    virtual size_t sizeOfIncludingThis(nsISupports* aSupports) override {
+        size_t n = 0;
+        nsCOMPtr<nsINode> node = do_QueryInterface(aSupports);
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=773533#c11 explains
+        // that we have to skip XBL elements because they violate certain
+        // assumptions.  Yuk.
+        if (node && !node->IsInUncomposedDoc() &&
+            !(node->IsElement() && node->AsElement()->IsInNamespace(kNameSpaceID_XBL)))
+        {
+            // This is an orphan node.  If we haven't already handled the
+            // sub-tree that this node belongs to, measure the sub-tree's size
+            // and then record its root so we don't measure it again.
+            nsCOMPtr<nsINode> orphanTree = node->SubtreeRoot();
+            if (orphanTree &&
+                !mAlreadyMeasuredOrphanTrees.Contains(orphanTree)) {
+                // If PutEntry() fails we don't measure this tree, which could
+                // lead to under-measurement. But that's better than the
+                // alternatives, which are over-measurement or an OOM abort.
+                if (mAlreadyMeasuredOrphanTrees.PutEntry(orphanTree, fallible)) {
+                    n += SizeOfTreeIncludingThis(orphanTree);
+                }
+            }
+        }
+        return n;
+    }
+
+  private:
+    nsTHashtable <nsISupportsHashKey> mAlreadyMeasuredOrphanTrees;
+};
+
+#ifdef DEBUG
+static bool
+StartsWithExplicit(nsACString& s)
+{
+    return StringBeginsWith(s, NS_LITERAL_CSTRING("explicit/"));
+}
+#endif
+
+class XPCJSContextStats : public JS::RuntimeStats
+{
+    WindowPaths* mWindowPaths;
+    WindowPaths* mTopWindowPaths;
+    bool mGetLocations;
+    int mAnonymizeID;
+
+  public:
+    XPCJSContextStats(WindowPaths* windowPaths, WindowPaths* topWindowPaths,
+                      bool getLocations, bool anonymize)
+      : JS::RuntimeStats(JSMallocSizeOf),
+        mWindowPaths(windowPaths),
+        mTopWindowPaths(topWindowPaths),
+        mGetLocations(getLocations),
+        mAnonymizeID(anonymize ? 1 : 0)
+    {}
+
+    ~XPCJSContextStats() {
+        for (size_t i = 0; i != compartmentStatsVector.length(); ++i)
+            delete static_cast<xpc::CompartmentStatsExtras*>(compartmentStatsVector[i].extra);
+
+
+        for (size_t i = 0; i != zoneStatsVector.length(); ++i)
+            delete static_cast<xpc::ZoneStatsExtras*>(zoneStatsVector[i].extra);
+    }
+
+    virtual void initExtraZoneStats(JS::Zone* zone, JS::ZoneStats* zStats) override {
+        // Get the compartment's global.
+        AutoSafeJSContext cx;
+        JSCompartment* comp = js::GetAnyCompartmentInZone(zone);
+        xpc::ZoneStatsExtras* extras = new xpc::ZoneStatsExtras;
+        extras->pathPrefix.AssignLiteral("explicit/js-non-window/zones/");
+        RootedObject global(cx, JS_GetGlobalForCompartmentOrNull(cx, comp));
+        if (global) {
+            RefPtr<nsGlobalWindow> window;
+            if (NS_SUCCEEDED(UNWRAP_OBJECT(Window, global, window))) {
+                // The global is a |window| object.  Use the path prefix that
+                // we should have already created for it.
+                if (mTopWindowPaths->Get(window->WindowID(),
+                                         &extras->pathPrefix))
+                    extras->pathPrefix.AppendLiteral("/js-");
+            }
+        }
+
+        extras->pathPrefix += nsPrintfCString("zone(0x%p)/", (void*)zone);
+
+        MOZ_ASSERT(StartsWithExplicit(extras->pathPrefix));
+
+        zStats->extra = extras;
+    }
+
+    virtual void initExtraCompartmentStats(JSCompartment* c,
+                                           JS::CompartmentStats* cstats) override
+    {
+        xpc::CompartmentStatsExtras* extras = new xpc::CompartmentStatsExtras;
+        nsCString cName;
+        GetCompartmentName(c, cName, &mAnonymizeID, /* replaceSlashes = */ true);
+        CompartmentPrivate* cp = CompartmentPrivate::Get(c);
+        if (cp) {
+            if (mGetLocations) {
+                cp->GetLocationURI(CompartmentPrivate::LocationHintAddon,
+                                   getter_AddRefs(extras->location));
+            }
+            // Note: cannot use amIAddonManager implementation at this point,
+            // as it is a JS service and the JS heap is currently not idle.
+            // Otherwise, we could have computed the add-on id at this point.
+        }
+
+        // Get the compartment's global.
+        AutoSafeJSContext cx;
+        bool needZone = true;
+        RootedObject global(cx, JS_GetGlobalForCompartmentOrNull(cx, c));
+        if (global) {
+            RefPtr<nsGlobalWindow> window;
+            if (NS_SUCCEEDED(UNWRAP_OBJECT(Window, global, window))) {
+                // The global is a |window| object.  Use the path prefix that
+                // we should have already created for it.
+                if (mWindowPaths->Get(window->WindowID(),
+                                      &extras->jsPathPrefix)) {
+                    extras->domPathPrefix.Assign(extras->jsPathPrefix);
+                    extras->domPathPrefix.AppendLiteral("/dom/");
+                    extras->jsPathPrefix.AppendLiteral("/js-");
+                    needZone = false;
+                } else {
+                    extras->jsPathPrefix.AssignLiteral("explicit/js-non-window/zones/");
+                    extras->domPathPrefix.AssignLiteral("explicit/dom/unknown-window-global?!/");
+                }
+            } else {
+                extras->jsPathPrefix.AssignLiteral("explicit/js-non-window/zones/");
+                extras->domPathPrefix.AssignLiteral("explicit/dom/non-window-global?!/");
+            }
+        } else {
+            extras->jsPathPrefix.AssignLiteral("explicit/js-non-window/zones/");
+            extras->domPathPrefix.AssignLiteral("explicit/dom/no-global?!/");
+        }
+
+        if (needZone)
+            extras->jsPathPrefix += nsPrintfCString("zone(0x%p)/", (void*)js::GetCompartmentZone(c));
+
+        extras->jsPathPrefix += NS_LITERAL_CSTRING("compartment(") + cName + NS_LITERAL_CSTRING(")/");
+
+        // extras->jsPathPrefix is used for almost all the compartment-specific
+        // reports. At this point it has the form
+        // "<something>compartment(<cname>)/".
+        //
+        // extras->domPathPrefix is used for DOM orphan nodes, which are
+        // counted by the JS reporter but reported as part of the DOM
+        // measurements. At this point it has the form "<something>/dom/" if
+        // this compartment belongs to an nsGlobalWindow, and
+        // "explicit/dom/<something>?!/" otherwise (in which case it shouldn't
+        // be used, because non-nsGlobalWindow compartments shouldn't have
+        // orphan DOM nodes).
+
+        MOZ_ASSERT(StartsWithExplicit(extras->jsPathPrefix));
+        MOZ_ASSERT(StartsWithExplicit(extras->domPathPrefix));
+
+        cstats->extra = extras;
+    }
+};
+
+void
+JSReporter::CollectReports(WindowPaths* windowPaths,
+                           WindowPaths* topWindowPaths,
+                           nsIHandleReportCallback* handleReport,
+                           nsISupports* data,
+                           bool anonymize)
+{
+    XPCJSContext* xpccx = nsXPConnect::GetContextInstance();
+
+    // In the first step we get all the stats and stash them in a local
+    // data structure.  In the second step we pass all the stashed stats to
+    // the callback.  Separating these steps is important because the
+    // callback may be a JS function, and executing JS while getting these
+    // stats seems like a bad idea.
+
+    nsCOMPtr<amIAddonManager> addonManager;
+    if (XRE_IsParentProcess()) {
+        // Only try to access the service from the main process.
+        addonManager = do_GetService("@mozilla.org/addons/integration;1");
+    }
+    bool getLocations = !!addonManager;
+    XPCJSContextStats rtStats(windowPaths, topWindowPaths, getLocations,
+                              anonymize);
+    OrphanReporter orphanReporter(XPCConvert::GetISupportsFromJSObject);
+    if (!JS::CollectRuntimeStats(xpccx->Context(), &rtStats, &orphanReporter,
+                                 anonymize))
+    {
+        return;
+    }
+
+    size_t xpcJSRuntimeSize = xpccx->SizeOfIncludingThis(JSMallocSizeOf);
+
+    size_t wrappedJSSize = xpccx->GetMultiCompartmentWrappedJSMap()->SizeOfWrappedJS(JSMallocSizeOf);
+
+    XPCWrappedNativeScope::ScopeSizeInfo sizeInfo(JSMallocSizeOf);
+    XPCWrappedNativeScope::AddSizeOfAllScopesIncludingThis(&sizeInfo);
+
+    mozJSComponentLoader* loader = mozJSComponentLoader::Get();
+    size_t jsComponentLoaderSize = loader ? loader->SizeOfIncludingThis(JSMallocSizeOf) : 0;
+
+    // This is the second step (see above).  First we report stuff in the
+    // "explicit" tree, then we report other stuff.
+
+    size_t rtTotal = 0;
+    xpc::ReportJSRuntimeExplicitTreeStats(rtStats,
+                                          NS_LITERAL_CSTRING("explicit/js-non-window/"),
+                                          addonManager, handleReport, data,
+                                          anonymize, &rtTotal);
+
+    // Report the sums of the compartment numbers.
+    xpc::CompartmentStatsExtras cExtrasTotal;
+    cExtrasTotal.jsPathPrefix.AssignLiteral("js-main-runtime/compartments/");
+    cExtrasTotal.domPathPrefix.AssignLiteral("window-objects/dom/");
+    ReportCompartmentStats(rtStats.cTotals, cExtrasTotal, addonManager,
+                           handleReport, data);
+
+    xpc::ZoneStatsExtras zExtrasTotal;
+    zExtrasTotal.pathPrefix.AssignLiteral("js-main-runtime/zones/");
+    ReportZoneStats(rtStats.zTotals, zExtrasTotal, handleReport, data,
+                    anonymize);
+
+    // Report the sum of the runtime/ numbers.
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime/runtime"),
+        KIND_OTHER, rtTotal,
+        "The sum of all measurements under 'explicit/js-non-window/runtime/'.");
+
+    // Report the numbers for memory outside of compartments.
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime/gc-heap/unused-chunks"),
+        KIND_OTHER, rtStats.gcHeapUnusedChunks,
+        "The same as 'explicit/js-non-window/gc-heap/unused-chunks'.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime/gc-heap/unused-arenas"),
+        KIND_OTHER, rtStats.gcHeapUnusedArenas,
+        "The same as 'explicit/js-non-window/gc-heap/unused-arenas'.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime/gc-heap/chunk-admin"),
+        KIND_OTHER, rtStats.gcHeapChunkAdmin,
+        "The same as 'explicit/js-non-window/gc-heap/chunk-admin'.");
+
+    // Report a breakdown of the committed GC space.
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/chunks"),
+        KIND_OTHER, rtStats.gcHeapUnusedChunks,
+        "The same as 'explicit/js-non-window/gc-heap/unused-chunks'.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/arenas"),
+        KIND_OTHER, rtStats.gcHeapUnusedArenas,
+        "The same as 'explicit/js-non-window/gc-heap/unused-arenas'.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/objects"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.object,
+        "Unused object cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/strings"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.string,
+        "Unused string cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/symbols"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.symbol,
+        "Unused symbol cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/shapes"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.shape,
+        "Unused shape cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/base-shapes"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.baseShape,
+        "Unused base shape cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/object-groups"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.objectGroup,
+        "Unused object group cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/scopes"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.scope,
+        "Unused scope cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/scripts"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.script,
+        "Unused script cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/lazy-scripts"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.lazyScript,
+        "Unused lazy script cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/unused/gc-things/jitcode"),
+        KIND_OTHER, rtStats.zTotals.unusedGCThings.jitcode,
+        "Unused jitcode cells within non-empty arenas.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/chunk-admin"),
+        KIND_OTHER, rtStats.gcHeapChunkAdmin,
+        "The same as 'explicit/js-non-window/gc-heap/chunk-admin'.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/arena-admin"),
+        KIND_OTHER, rtStats.zTotals.gcHeapArenaAdmin,
+        "The same as 'js-main-runtime/zones/gc-heap-arena-admin'.");
+
+    size_t gcThingTotal = 0;
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/objects"),
+        KIND_OTHER, rtStats.cTotals.classInfo.objectsGCHeap,
+        "Used object cells.");
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/strings"),
+        KIND_OTHER, rtStats.zTotals.stringInfo.sizeOfLiveGCThings(),
+        "Used string cells.");
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/symbols"),
+        KIND_OTHER, rtStats.zTotals.symbolsGCHeap,
+        "Used symbol cells.");
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/shapes"),
+        KIND_OTHER,
+        rtStats.zTotals.shapeInfo.shapesGCHeapTree + rtStats.zTotals.shapeInfo.shapesGCHeapDict,
+        "Used shape cells.");
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/base-shapes"),
+        KIND_OTHER, rtStats.zTotals.shapeInfo.shapesGCHeapBase,
+        "Used base shape cells.");
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/object-groups"),
+        KIND_OTHER, rtStats.zTotals.objectGroupsGCHeap,
+        "Used object group cells.");
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/scopes"),
+        KIND_OTHER, rtStats.zTotals.scopesGCHeap,
+        "Used scope cells.");
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/scripts"),
+        KIND_OTHER, rtStats.cTotals.scriptsGCHeap,
+        "Used script cells.");
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/lazy-scripts"),
+        KIND_OTHER, rtStats.zTotals.lazyScriptsGCHeap,
+        "Used lazy script cells.");
+
+    MREPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime-gc-heap-committed/used/gc-things/jitcode"),
+        KIND_OTHER, rtStats.zTotals.jitCodesGCHeap,
+        "Used jitcode cells.");
+
+    MOZ_ASSERT(gcThingTotal == rtStats.gcHeapGCThings);
+
+    // Report xpconnect.
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("explicit/xpconnect/runtime"),
+        KIND_HEAP, xpcJSRuntimeSize,
+        "The XPConnect runtime.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("explicit/xpconnect/wrappedjs"),
+        KIND_HEAP, wrappedJSSize,
+        "Wrappers used to implement XPIDL interfaces with JS.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("explicit/xpconnect/scopes"),
+        KIND_HEAP, sizeInfo.mScopeAndMapSize,
+        "XPConnect scopes.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("explicit/xpconnect/proto-iface-cache"),
+        KIND_HEAP, sizeInfo.mProtoAndIfaceCacheSize,
+        "Prototype and interface binding caches.");
+
+    REPORT_BYTES(NS_LITERAL_CSTRING("explicit/xpconnect/js-component-loader"),
+        KIND_HEAP, jsComponentLoaderSize,
+        "XPConnect's JS component loader.");
+}
+
+static nsresult
+JSSizeOfTab(JSObject* objArg, size_t* jsObjectsSize, size_t* jsStringsSize,
+            size_t* jsPrivateSize, size_t* jsOtherSize)
+{
+    JSContext* cx = nsXPConnect::GetContextInstance()->Context();
+    JS::RootedObject obj(cx, objArg);
+
+    TabSizes sizes;
+    OrphanReporter orphanReporter(XPCConvert::GetISupportsFromJSObject);
+    NS_ENSURE_TRUE(JS::AddSizeOfTab(cx, obj, moz_malloc_size_of,
+                                    &orphanReporter, &sizes),
+                   NS_ERROR_OUT_OF_MEMORY);
+
+    *jsObjectsSize = sizes.objects;
+    *jsStringsSize = sizes.strings;
+    *jsPrivateSize = sizes.private_;
+    *jsOtherSize   = sizes.other;
+    return NS_OK;
+}
+
+} // namespace xpc
+
+static void
+AccumulateTelemetryCallback(int id, uint32_t sample, const char* key)
+{
+    switch (id) {
+      case JS_TELEMETRY_GC_REASON:
+        Telemetry::Accumulate(Telemetry::GC_REASON_2, sample);
+        break;
+      case JS_TELEMETRY_GC_IS_ZONE_GC:
+        Telemetry::Accumulate(Telemetry::GC_IS_COMPARTMENTAL, sample);
+        break;
+      case JS_TELEMETRY_GC_MS:
+        Telemetry::Accumulate(Telemetry::GC_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_BUDGET_MS:
+        Telemetry::Accumulate(Telemetry::GC_BUDGET_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_ANIMATION_MS:
+        Telemetry::Accumulate(Telemetry::GC_ANIMATION_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_MAX_PAUSE_MS:
+        Telemetry::Accumulate(Telemetry::GC_MAX_PAUSE_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_MARK_MS:
+        Telemetry::Accumulate(Telemetry::GC_MARK_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_SWEEP_MS:
+        Telemetry::Accumulate(Telemetry::GC_SWEEP_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_COMPACT_MS:
+        Telemetry::Accumulate(Telemetry::GC_COMPACT_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_MARK_ROOTS_MS:
+        Telemetry::Accumulate(Telemetry::GC_MARK_ROOTS_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_MARK_GRAY_MS:
+        Telemetry::Accumulate(Telemetry::GC_MARK_GRAY_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_SLICE_MS:
+        Telemetry::Accumulate(Telemetry::GC_SLICE_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_SLOW_PHASE:
+        Telemetry::Accumulate(Telemetry::GC_SLOW_PHASE, sample);
+        break;
+      case JS_TELEMETRY_GC_MMU_50:
+        Telemetry::Accumulate(Telemetry::GC_MMU_50, sample);
+        break;
+      case JS_TELEMETRY_GC_RESET:
+        Telemetry::Accumulate(Telemetry::GC_RESET, sample);
+        break;
+      case JS_TELEMETRY_GC_RESET_REASON:
+        Telemetry::Accumulate(Telemetry::GC_RESET_REASON, sample);
+        break;
+      case JS_TELEMETRY_GC_INCREMENTAL_DISABLED:
+        Telemetry::Accumulate(Telemetry::GC_INCREMENTAL_DISABLED, sample);
+        break;
+      case JS_TELEMETRY_GC_NON_INCREMENTAL:
+        Telemetry::Accumulate(Telemetry::GC_NON_INCREMENTAL, sample);
+        break;
+      case JS_TELEMETRY_GC_NON_INCREMENTAL_REASON:
+        Telemetry::Accumulate(Telemetry::GC_NON_INCREMENTAL_REASON, sample);
+        break;
+      case JS_TELEMETRY_GC_SCC_SWEEP_TOTAL_MS:
+        Telemetry::Accumulate(Telemetry::GC_SCC_SWEEP_TOTAL_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_SCC_SWEEP_MAX_PAUSE_MS:
+        Telemetry::Accumulate(Telemetry::GC_SCC_SWEEP_MAX_PAUSE_MS, sample);
+        break;
+      case JS_TELEMETRY_GC_MINOR_REASON:
+        Telemetry::Accumulate(Telemetry::GC_MINOR_REASON, sample);
+        break;
+      case JS_TELEMETRY_GC_MINOR_REASON_LONG:
+        Telemetry::Accumulate(Telemetry::GC_MINOR_REASON_LONG, sample);
+        break;
+      case JS_TELEMETRY_GC_MINOR_US:
+        Telemetry::Accumulate(Telemetry::GC_MINOR_US, sample);
+        break;
+      case JS_TELEMETRY_GC_NURSERY_BYTES:
+        Telemetry::Accumulate(Telemetry::GC_NURSERY_BYTES, sample);
+        break;
+      case JS_TELEMETRY_GC_PRETENURE_COUNT:
+        Telemetry::Accumulate(Telemetry::GC_PRETENURE_COUNT, sample);
+        break;
+      case JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_CONTENT:
+        Telemetry::Accumulate(Telemetry::JS_DEPRECATED_LANGUAGE_EXTENSIONS_IN_CONTENT, sample);
+        break;
+      case JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_ADDONS:
+        Telemetry::Accumulate(Telemetry::JS_DEPRECATED_LANGUAGE_EXTENSIONS_IN_ADDONS, sample);
+        break;
+      case JS_TELEMETRY_ADDON_EXCEPTIONS:
+        Telemetry::Accumulate(Telemetry::JS_TELEMETRY_ADDON_EXCEPTIONS, nsDependentCString(key), sample);
+        break;
+      case JS_TELEMETRY_AOT_USAGE:
+        Telemetry::Accumulate(Telemetry::JS_AOT_USAGE, sample);
+        break;
+      default:
+        MOZ_ASSERT_UNREACHABLE("Unexpected JS_TELEMETRY id");
+    }
+}
+
+static void
+CompartmentNameCallback(JSContext* cx, JSCompartment* comp,
+                        char* buf, size_t bufsize)
+{
+    nsCString name;
+    // This is called via the JSAPI and isn't involved in memory reporting, so
+    // we don't need to anonymize compartment names.
+    int anonymizeID = 0;
+    GetCompartmentName(comp, name, &anonymizeID, /* replaceSlashes = */ false);
+    if (name.Length() >= bufsize)
+        name.Truncate(bufsize - 1);
+    memcpy(buf, name.get(), name.Length() + 1);
+}
+
+static bool
+PreserveWrapper(JSContext* cx, JSObject* obj)
+{
+    MOZ_ASSERT(cx);
+    MOZ_ASSERT(obj);
+    MOZ_ASSERT(IS_WN_REFLECTOR(obj) || mozilla::dom::IsDOMObject(obj));
+
+    return mozilla::dom::IsDOMObject(obj) && mozilla::dom::TryPreserveWrapper(obj);
+}
+
+static nsresult
+ReadSourceFromFilename(JSContext* cx, const char* filename, char16_t** src, size_t* len)
+{
+    nsresult rv;
+
+    // mozJSSubScriptLoader prefixes the filenames of the scripts it loads with
+    // the filename of its caller. Axe that if present.
+    const char* arrow;
+    while ((arrow = strstr(filename, " -> ")))
+        filename = arrow + strlen(" -> ");
+
+    // Get the URI.
+    nsCOMPtr<nsIURI> uri;
+    rv = NS_NewURI(getter_AddRefs(uri), filename);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIChannel> scriptChannel;
+    rv = NS_NewChannel(getter_AddRefs(scriptChannel),
+                       uri,
+                       nsContentUtils::GetSystemPrincipal(),
+                       nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
+                       nsIContentPolicy::TYPE_OTHER);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Only allow local reading.
+    nsCOMPtr<nsIURI> actualUri;
+    rv = scriptChannel->GetURI(getter_AddRefs(actualUri));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCString scheme;
+    rv = actualUri->GetScheme(scheme);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!scheme.EqualsLiteral("file") && !scheme.EqualsLiteral("jar"))
+        return NS_OK;
+
+    // Explicitly set the content type so that we don't load the
+    // exthandler to guess it.
+    scriptChannel->SetContentType(NS_LITERAL_CSTRING("text/plain"));
+
+    nsCOMPtr<nsIInputStream> scriptStream;
+    rv = scriptChannel->Open2(getter_AddRefs(scriptStream));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    uint64_t rawLen;
+    rv = scriptStream->Available(&rawLen);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!rawLen)
+        return NS_ERROR_FAILURE;
+
+    // Technically, this should be SIZE_MAX, but we don't run on machines
+    // where that would be less than UINT32_MAX, and the latter is already
+    // well beyond a reasonable limit.
+    if (rawLen > UINT32_MAX)
+        return NS_ERROR_FILE_TOO_BIG;
+
+    // Allocate an internal buf the size of the file.
+    auto buf = MakeUniqueFallible<unsigned char[]>(rawLen);
+    if (!buf)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    unsigned char* ptr = buf.get();
+    unsigned char* end = ptr + rawLen;
+    while (ptr < end) {
+        uint32_t bytesRead;
+        rv = scriptStream->Read(reinterpret_cast<char*>(ptr), end - ptr, &bytesRead);
+        if (NS_FAILED(rv))
+            return rv;
+        MOZ_ASSERT(bytesRead > 0, "stream promised more bytes before EOF");
+        ptr += bytesRead;
+    }
+
+    rv = nsScriptLoader::ConvertToUTF16(scriptChannel, buf.get(), rawLen, EmptyString(),
+                                        nullptr, *src, *len);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!*src)
+        return NS_ERROR_FAILURE;
+
+    // Historically this method used JS_malloc() which updates the GC memory
+    // accounting.  Since ConvertToUTF16() now uses js_malloc() instead we
+    // update the accounting manually after the fact.
+    JS_updateMallocCounter(cx, *len);
+
+    return NS_OK;
+}
+
+// The JS engine calls this object's 'load' member function when it needs
+// the source for a chrome JS function. See the comment in the XPCJSContext
+// constructor.
+class XPCJSSourceHook: public js::SourceHook {
+    bool load(JSContext* cx, const char* filename, char16_t** src, size_t* length) {
+        *src = nullptr;
+        *length = 0;
+
+        if (!nsContentUtils::IsCallerChrome())
+            return true;
+
+        if (!filename)
+            return true;
+
+        nsresult rv = ReadSourceFromFilename(cx, filename, src, length);
+        if (NS_FAILED(rv)) {
+            xpc::Throw(cx, rv);
+            return false;
+        }
+
+        return true;
+    }
+};
+
+static const JSWrapObjectCallbacks WrapObjectCallbacks = {
+    xpc::WrapperFactory::Rewrap,
+    xpc::WrapperFactory::PrepareForWrapping
+};
+
+XPCJSContext::XPCJSContext()
+ : mCallContext(nullptr),
+   mAutoRoots(nullptr),
+   mResolveName(JSID_VOID),
+   mResolvingWrapper(nullptr),
+   mWrappedJSMap(JSObject2WrappedJSMap::newMap(XPC_JS_MAP_LENGTH)),
+   mWrappedJSClassMap(IID2WrappedJSClassMap::newMap(XPC_JS_CLASS_MAP_LENGTH)),
+   mIID2NativeInterfaceMap(IID2NativeInterfaceMap::newMap(XPC_NATIVE_INTERFACE_MAP_LENGTH)),
+   mClassInfo2NativeSetMap(ClassInfo2NativeSetMap::newMap(XPC_NATIVE_SET_MAP_LENGTH)),
+   mNativeSetMap(NativeSetMap::newMap(XPC_NATIVE_SET_MAP_LENGTH)),
+   mThisTranslatorMap(IID2ThisTranslatorMap::newMap(XPC_THIS_TRANSLATOR_MAP_LENGTH)),
+   mDyingWrappedNativeProtoMap(XPCWrappedNativeProtoMap::newMap(XPC_DYING_NATIVE_PROTO_MAP_LENGTH)),
+   mGCIsRunning(false),
+   mNativesToReleaseArray(),
+   mDoingFinalization(false),
+   mVariantRoots(nullptr),
+   mWrappedJSRoots(nullptr),
+   mObjectHolderRoots(nullptr),
+   mWatchdogManager(new WatchdogManager(this)),
+   mAsyncSnowWhiteFreer(new AsyncFreeSnowWhite()),
+   mSlowScriptSecondHalf(false),
+   mTimeoutAccumulated(false),
+   mPendingResult(NS_OK)
+{
+}
+
+#ifdef XP_WIN
+static size_t
+GetWindowsStackSize()
+{
+    // First, get the stack base. Because the stack grows down, this is the top
+    // of the stack.
+    const uint8_t* stackTop;
+#ifdef _WIN64
+    PNT_TIB64 pTib = reinterpret_cast<PNT_TIB64>(NtCurrentTeb());
+    stackTop = reinterpret_cast<const uint8_t*>(pTib->StackBase);
+#else
+    PNT_TIB pTib = reinterpret_cast<PNT_TIB>(NtCurrentTeb());
+    stackTop = reinterpret_cast<const uint8_t*>(pTib->StackBase);
+#endif
+
+    // Now determine the stack bottom. Note that we can't use tib->StackLimit,
+    // because that's the size of the committed area and we're also interested
+    // in the reserved pages below that.
+    MEMORY_BASIC_INFORMATION mbi;
+    if (!VirtualQuery(&mbi, &mbi, sizeof(mbi)))
+        MOZ_CRASH("VirtualQuery failed");
+
+    const uint8_t* stackBottom = reinterpret_cast<const uint8_t*>(mbi.AllocationBase);
+
+    // Do some sanity checks.
+    size_t stackSize = size_t(stackTop - stackBottom);
+    MOZ_RELEASE_ASSERT(stackSize >= 1 * 1024 * 1024);
+    MOZ_RELEASE_ASSERT(stackSize <= 32 * 1024 * 1024);
+
+    // Subtract 40 KB (Win32) or 80 KB (Win64) to account for things like
+    // the guard page and large PGO stack frames.
+    return stackSize - 10 * sizeof(uintptr_t) * 1024;
+}
+#endif
+
+nsresult
+XPCJSContext::Initialize()
+{
+    nsresult rv = CycleCollectedJSContext::Initialize(nullptr,
+                                                      JS::DefaultHeapMaxBytes,
+                                                      JS::DefaultNurseryBytes);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    MOZ_ASSERT(Context());
+    JSContext* cx = Context();
+
+    mUnprivilegedJunkScope.init(cx, nullptr);
+    mPrivilegedJunkScope.init(cx, nullptr);
+    mCompilationScope.init(cx, nullptr);
+
+    // these jsids filled in later when we have a JSContext to work with.
+    mStrIDs[0] = JSID_VOID;
+
+    auto cxPrivate = new PerThreadAtomCache();
+    memset(cxPrivate, 0, sizeof(PerThreadAtomCache));
+    JS_SetContextPrivate(cx, cxPrivate);
+
+    // Unconstrain the runtime's threshold on nominal heap size, to avoid
+    // triggering GC too often if operating continuously near an arbitrary
+    // finite threshold (0xffffffff is infinity for uint32_t parameters).
+    // This leaves the maximum-JS_malloc-bytes threshold still in effect
+    // to cause period, and we hope hygienic, last-ditch GCs from within
+    // the GC's allocator.
+    JS_SetGCParameter(cx, JSGC_MAX_BYTES, 0xffffffff);
+
+    // The JS engine permits us to set different stack limits for system code,
+    // trusted script, and untrusted script. We have tests that ensure that
+    // we can always execute 10 "heavy" (eval+with) stack frames deeper in
+    // privileged code. Our stack sizes vary greatly in different configurations,
+    // so satisfying those tests requires some care. Manual measurements of the
+    // number of heavy stack frames achievable gives us the following rough data,
+    // ordered by the effective categories in which they are grouped in the
+    // JS_SetNativeStackQuota call (which predates this analysis).
+    //
+    // (NB: These numbers may have drifted recently - see bug 938429)
+    // OSX 64-bit Debug: 7MB stack, 636 stack frames => ~11.3k per stack frame
+    // OSX64 Opt: 7MB stack, 2440 stack frames => ~3k per stack frame
+    //
+    // Linux 32-bit Debug: 2MB stack, 426 stack frames => ~4.8k per stack frame
+    // Linux 64-bit Debug: 4MB stack, 455 stack frames => ~9.0k per stack frame
+    //
+    // Windows (Opt+Debug): 900K stack, 235 stack frames => ~3.4k per stack frame
+    //
+    // Linux 32-bit Opt: 1MB stack, 272 stack frames => ~3.8k per stack frame
+    // Linux 64-bit Opt: 2MB stack, 316 stack frames => ~6.5k per stack frame
+    //
+    // We tune the trusted/untrusted quotas for each configuration to achieve our
+    // invariants while attempting to minimize overhead. In contrast, our buffer
+    // between system code and trusted script is a very unscientific 10k.
+    const size_t kSystemCodeBuffer = 10 * 1024;
+
+    // Our "default" stack is what we use in configurations where we don't have
+    // a compelling reason to do things differently. This is effectively 512KB
+    // on 32-bit platforms and 1MB on 64-bit platforms.
+    const size_t kDefaultStackQuota = 128 * sizeof(size_t) * 1024;
+
+    // Set stack sizes for different configurations. It's probably not great for
+    // the web to base this decision primarily on the default stack size that the
+    // underlying platform makes available, but that seems to be what we do. :-(
+
+#if defined(XP_MACOSX) || defined(DARWIN)
+    // MacOS has a gargantuan default stack size of 8MB. Go wild with 7MB,
+    // and give trusted script 180k extra. The stack is huge on mac anyway.
+    const size_t kStackQuota = 7 * 1024 * 1024;
+    const size_t kTrustedScriptBuffer = 180 * 1024;
+#elif defined(MOZ_ASAN)
+    // ASan requires more stack space due to red-zones, so give it double the
+    // default (1MB on 32-bit, 2MB on 64-bit). ASAN stack frame measurements
+    // were not taken at the time of this writing, so we hazard a guess that
+    // ASAN builds have roughly thrice the stack overhead as normal builds.
+    // On normal builds, the largest stack frame size we might encounter is
+    // 9.0k (see above), so let's use a buffer of 9.0 * 5 * 10 = 450k.
+    const size_t kStackQuota =  2 * kDefaultStackQuota;
+    const size_t kTrustedScriptBuffer = 450 * 1024;
+#elif defined(XP_WIN)
+    // 1MB is the default stack size on Windows. We use the /STACK linker flag
+    // to request a larger stack, so we determine the stack size at runtime.
+    const size_t kStackQuota = GetWindowsStackSize();
+    const size_t kTrustedScriptBuffer = (sizeof(size_t) == 8) ? 180 * 1024   //win64
+                                                              : 120 * 1024;  //win32
+    // The following two configurations are linux-only. Given the numbers above,
+    // we use 50k and 100k trusted buffers on 32-bit and 64-bit respectively.
+#elif defined(ANDROID)
+    // Android appears to have 1MB stacks. Allow the use of 3/4 of that size
+    // (768KB on 32-bit), since otherwise we can crash with a stack overflow
+    // when nearing the 1MB limit.
+    const size_t kStackQuota = kDefaultStackQuota + kDefaultStackQuota / 2;
+    const size_t kTrustedScriptBuffer = sizeof(size_t) * 12800;
+#elif defined(DEBUG)
+    // Bug 803182: account for the 4x difference in the size of js::Interpret
+    // between optimized and debug builds.
+    // XXXbholley - Then why do we only account for 2x of difference?
+    const size_t kStackQuota = 2 * kDefaultStackQuota;
+    const size_t kTrustedScriptBuffer = sizeof(size_t) * 12800;
+#else
+    const size_t kStackQuota = kDefaultStackQuota;
+    const size_t kTrustedScriptBuffer = sizeof(size_t) * 12800;
+#endif
+
+    // Avoid an unused variable warning on platforms where we don't use the
+    // default.
+    (void) kDefaultStackQuota;
+
+    JS_SetNativeStackQuota(cx,
+                           kStackQuota,
+                           kStackQuota - kSystemCodeBuffer,
+                           kStackQuota - kSystemCodeBuffer - kTrustedScriptBuffer);
+
+    JS_SetDestroyCompartmentCallback(cx, CompartmentDestroyedCallback);
+    JS_SetSizeOfIncludingThisCompartmentCallback(cx, CompartmentSizeOfIncludingThisCallback);
+    JS_SetCompartmentNameCallback(cx, CompartmentNameCallback);
+    mPrevGCSliceCallback = JS::SetGCSliceCallback(cx, GCSliceCallback);
+    mPrevDoCycleCollectionCallback = JS::SetDoCycleCollectionCallback(cx,
+            DoCycleCollectionCallback);
+    JS_AddFinalizeCallback(cx, FinalizeCallback, nullptr);
+    JS_AddWeakPointerZoneGroupCallback(cx, WeakPointerZoneGroupCallback, this);
+    JS_AddWeakPointerCompartmentCallback(cx, WeakPointerCompartmentCallback, this);
+    JS_SetWrapObjectCallbacks(cx, &WrapObjectCallbacks);
+    js::SetPreserveWrapperCallback(cx, PreserveWrapper);
+#ifdef MOZ_ENABLE_PROFILER_SPS
+    if (PseudoStack* stack = mozilla_get_pseudo_stack())
+        stack->sampleContext(cx);
+#endif
+    JS_SetAccumulateTelemetryCallback(cx, AccumulateTelemetryCallback);
+    js::SetActivityCallback(cx, ActivityCallback, this);
+    JS_AddInterruptCallback(cx, InterruptCallback);
+    js::SetWindowProxyClass(cx, &OuterWindowProxyClass);
+
+    // The JS engine needs to keep the source code around in order to implement
+    // Function.prototype.toSource(). It'd be nice to not have to do this for
+    // chrome code and simply stub out requests for source on it. Life is not so
+    // easy, unfortunately. Nobody relies on chrome toSource() working in core
+    // browser code, but chrome tests use it. The worst offenders are addons,
+    // which like to monkeypatch chrome functions by calling toSource() on them
+    // and using regular expressions to modify them. We avoid keeping most browser
+    // JS source code in memory by setting LAZY_SOURCE on JS::CompileOptions when
+    // compiling some chrome code. This causes the JS engine not save the source
+    // code in memory. When the JS engine is asked to provide the source for a
+    // function compiled with LAZY_SOURCE, it calls SourceHook to load it.
+    ///
+    // Note we do have to retain the source code in memory for scripts compiled in
+    // isRunOnce mode and compiled function bodies (from
+    // JS::CompileFunction). In practice, this means content scripts and event
+    // handlers.
+    UniquePtr<XPCJSSourceHook> hook(new XPCJSSourceHook);
+    js::SetSourceHook(cx, Move(hook));
+
+    // Set up locale information and callbacks for the newly-created context so
+    // that the various toLocaleString() methods, localeCompare(), and other
+    // internationalization APIs work as desired.
+    if (!xpc_LocalizeContext(cx))
+        NS_RUNTIMEABORT("xpc_LocalizeContext failed.");
+
+    // Register memory reporters and distinguished amount functions.
+    RegisterStrongMemoryReporter(new JSMainRuntimeCompartmentsReporter());
+    RegisterStrongMemoryReporter(new JSMainRuntimeTemporaryPeakReporter());
+    RegisterJSMainRuntimeGCHeapDistinguishedAmount(JSMainRuntimeGCHeapDistinguishedAmount);
+    RegisterJSMainRuntimeTemporaryPeakDistinguishedAmount(JSMainRuntimeTemporaryPeakDistinguishedAmount);
+    RegisterJSMainRuntimeCompartmentsSystemDistinguishedAmount(JSMainRuntimeCompartmentsSystemDistinguishedAmount);
+    RegisterJSMainRuntimeCompartmentsUserDistinguishedAmount(JSMainRuntimeCompartmentsUserDistinguishedAmount);
+    mozilla::RegisterJSSizeOfTab(JSSizeOfTab);
+
+    // Watch for the JS boolean options.
+    ReloadPrefsCallback(nullptr, this);
+    Preferences::RegisterCallback(ReloadPrefsCallback, JS_OPTIONS_DOT_STR, this);
+
+    return NS_OK;
+}
+
+// static
+XPCJSContext*
+XPCJSContext::newXPCJSContext()
+{
+    XPCJSContext* self = new XPCJSContext();
+    nsresult rv = self->Initialize();
+    if (NS_FAILED(rv)) {
+        NS_RUNTIMEABORT("new XPCJSContext failed to initialize.");
+        delete self;
+        return nullptr;
+    }
+
+    if (self->Context()                         &&
+        self->GetMultiCompartmentWrappedJSMap() &&
+        self->GetWrappedJSClassMap()            &&
+        self->GetIID2NativeInterfaceMap()       &&
+        self->GetClassInfo2NativeSetMap()       &&
+        self->GetNativeSetMap()                 &&
+        self->GetThisTranslatorMap()            &&
+        self->GetDyingWrappedNativeProtoMap()   &&
+        self->mWatchdogManager) {
+        return self;
+    }
+
+    NS_RUNTIMEABORT("new XPCJSContext failed to initialize.");
+
+    delete self;
+    return nullptr;
+}
+
+bool
+XPCJSContext::JSContextInitialized(JSContext* cx)
+{
+    JSAutoRequest ar(cx);
+
+    // if it is our first context then we need to generate our string ids
+    if (JSID_IS_VOID(mStrIDs[0])) {
+        RootedString str(cx);
+        for (unsigned i = 0; i < IDX_TOTAL_COUNT; i++) {
+            str = JS_AtomizeAndPinString(cx, mStrings[i]);
+            if (!str) {
+                mStrIDs[0] = JSID_VOID;
+                return false;
+            }
+            mStrIDs[i] = INTERNED_STRING_TO_JSID(cx, str);
+            mStrJSVals[i].setString(str);
+        }
+
+        if (!mozilla::dom::DefineStaticJSVals(cx)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+XPCJSContext::DescribeCustomObjects(JSObject* obj, const js::Class* clasp,
+                                    char (&name)[72]) const
+{
+    XPCNativeScriptableInfo* si = nullptr;
+
+    if (!IS_PROTO_CLASS(clasp)) {
+        return false;
+    }
+
+    XPCWrappedNativeProto* p =
+        static_cast<XPCWrappedNativeProto*>(xpc_GetJSPrivate(obj));
+    si = p->GetScriptableInfo();
+
+    if (!si) {
+        return false;
+    }
+
+    SprintfLiteral(name, "JS Object (%s - %s)", clasp->name, si->GetJSClass()->name);
+    return true;
+}
+
+bool
+XPCJSContext::NoteCustomGCThingXPCOMChildren(const js::Class* clasp, JSObject* obj,
+                                             nsCycleCollectionTraversalCallback& cb) const
+{
+    if (clasp != &XPC_WN_Tearoff_JSClass) {
+        return false;
+    }
+
+    // A tearoff holds a strong reference to its native object
+    // (see XPCWrappedNative::FlatJSObjectFinalized). Its XPCWrappedNative
+    // will be held alive through the parent of the JSObject of the tearoff.
+    XPCWrappedNativeTearOff* to =
+        static_cast<XPCWrappedNativeTearOff*>(xpc_GetJSPrivate(obj));
+    NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "xpc_GetJSPrivate(obj)->mNative");
+    cb.NoteXPCOMChild(to->GetNative());
+    return true;
+}
+
+void
+XPCJSContext::BeforeProcessTask(bool aMightBlock)
+{
+    MOZ_ASSERT(NS_IsMainThread());
+
+    // If ProcessNextEvent was called during a Promise "then" callback, we
+    // must process any pending microtasks before blocking in the event loop,
+    // otherwise we may deadlock until an event enters the queue later.
+    if (aMightBlock) {
+        if (Promise::PerformMicroTaskCheckpoint()) {
+            // If any microtask was processed, we post a dummy event in order to
+            // force the ProcessNextEvent call not to block.  This is required
+            // to support nested event loops implemented using a pattern like
+            // "while (condition) thread.processNextEvent(true)", in case the
+            // condition is triggered here by a Promise "then" callback.
+
+            NS_DispatchToMainThread(new Runnable());
+        }
+    }
+
+    // Start the slow script timer.
+    mSlowScriptCheckpoint = mozilla::TimeStamp::NowLoRes();
+    mSlowScriptSecondHalf = false;
+    mSlowScriptActualWait = mozilla::TimeDuration();
+    mTimeoutAccumulated = false;
+
+    // As we may be entering a nested event loop, we need to
+    // cancel any ongoing performance measurement.
+    js::ResetPerformanceMonitoring(Get()->Context());
+
+    CycleCollectedJSContext::BeforeProcessTask(aMightBlock);
+}
+
+void
+XPCJSContext::AfterProcessTask(uint32_t aNewRecursionDepth)
+{
+    // Now that we're back to the event loop, reset the slow script checkpoint.
+    mSlowScriptCheckpoint = mozilla::TimeStamp();
+    mSlowScriptSecondHalf = false;
+
+    // Call cycle collector occasionally.
+    MOZ_ASSERT(NS_IsMainThread());
+    nsJSContext::MaybePokeCC();
+
+    CycleCollectedJSContext::AfterProcessTask(aNewRecursionDepth);
+
+    // Now that we are certain that the event is complete,
+    // we can flush any ongoing performance measurement.
+    js::FlushPerformanceMonitoring(Get()->Context());
+
+    mozilla::jsipc::AfterProcessTask();
+}
+
+/***************************************************************************/
+
+void
+XPCJSContext::DebugDump(int16_t depth)
+{
+#ifdef DEBUG
+    depth--;
+    XPC_LOG_ALWAYS(("XPCJSContext @ %x", this));
+        XPC_LOG_INDENT();
+        XPC_LOG_ALWAYS(("mJSContext @ %x", Context()));
+
+        XPC_LOG_ALWAYS(("mWrappedJSClassMap @ %x with %d wrapperclasses(s)",
+                        mWrappedJSClassMap, mWrappedJSClassMap->Count()));
+        // iterate wrappersclasses...
+        if (depth && mWrappedJSClassMap->Count()) {
+            XPC_LOG_INDENT();
+            for (auto i = mWrappedJSClassMap->Iter(); !i.Done(); i.Next()) {
+                auto entry = static_cast<IID2WrappedJSClassMap::Entry*>(i.Get());
+                entry->value->DebugDump(depth);
+            }
+            XPC_LOG_OUTDENT();
+        }
+
+        // iterate wrappers...
+        XPC_LOG_ALWAYS(("mWrappedJSMap @ %x with %d wrappers(s)",
+                        mWrappedJSMap, mWrappedJSMap->Count()));
+        if (depth && mWrappedJSMap->Count()) {
+            XPC_LOG_INDENT();
+            mWrappedJSMap->Dump(depth);
+            XPC_LOG_OUTDENT();
+        }
+
+        XPC_LOG_ALWAYS(("mIID2NativeInterfaceMap @ %x with %d interface(s)",
+                        mIID2NativeInterfaceMap,
+                        mIID2NativeInterfaceMap->Count()));
+
+        XPC_LOG_ALWAYS(("mClassInfo2NativeSetMap @ %x with %d sets(s)",
+                        mClassInfo2NativeSetMap,
+                        mClassInfo2NativeSetMap->Count()));
+
+        XPC_LOG_ALWAYS(("mThisTranslatorMap @ %x with %d translator(s)",
+                        mThisTranslatorMap, mThisTranslatorMap->Count()));
+
+        XPC_LOG_ALWAYS(("mNativeSetMap @ %x with %d sets(s)",
+                        mNativeSetMap, mNativeSetMap->Count()));
+
+        // iterate sets...
+        if (depth && mNativeSetMap->Count()) {
+            XPC_LOG_INDENT();
+            for (auto i = mNativeSetMap->Iter(); !i.Done(); i.Next()) {
+                auto entry = static_cast<NativeSetMap::Entry*>(i.Get());
+                entry->key_value->DebugDump(depth);
+            }
+            XPC_LOG_OUTDENT();
+        }
+
+        XPC_LOG_ALWAYS(("mPendingResult of %x", mPendingResult));
+
+        XPC_LOG_OUTDENT();
+#endif
+}
+
+/***************************************************************************/
+
+void
+XPCRootSetElem::AddToRootSet(XPCRootSetElem** listHead)
+{
+    MOZ_ASSERT(!mSelfp, "Must be not linked");
+
+    mSelfp = listHead;
+    mNext = *listHead;
+    if (mNext) {
+        MOZ_ASSERT(mNext->mSelfp == listHead, "Must be list start");
+        mNext->mSelfp = &mNext;
+    }
+    *listHead = this;
+}
+
+void
+XPCRootSetElem::RemoveFromRootSet()
+{
+    nsXPConnect* xpc = nsXPConnect::XPConnect();
+    JS::PokeGC(xpc->GetContext()->Context());
+
+    MOZ_ASSERT(mSelfp, "Must be linked");
+
+    MOZ_ASSERT(*mSelfp == this, "Link invariant");
+    *mSelfp = mNext;
+    if (mNext)
+        mNext->mSelfp = mSelfp;
+#ifdef DEBUG
+    mSelfp = nullptr;
+    mNext = nullptr;
+#endif
+}
+
+void
+XPCJSContext::AddGCCallback(xpcGCCallback cb)
+{
+    MOZ_ASSERT(cb, "null callback");
+    extraGCCallbacks.AppendElement(cb);
+}
+
+void
+XPCJSContext::RemoveGCCallback(xpcGCCallback cb)
+{
+    MOZ_ASSERT(cb, "null callback");
+    bool found = extraGCCallbacks.RemoveElement(cb);
+    if (!found) {
+        NS_ERROR("Removing a callback which was never added.");
+    }
+}
+
+void
+XPCJSContext::InitSingletonScopes()
+{
+    // This all happens very early, so we don't bother with cx pushing.
+    JSContext* cx = Context();
+    JSAutoRequest ar(cx);
+    RootedValue v(cx);
+    nsresult rv;
+
+    // Create the Unprivileged Junk Scope.
+    SandboxOptions unprivilegedJunkScopeOptions;
+    unprivilegedJunkScopeOptions.sandboxName.AssignLiteral("XPConnect Junk Compartment");
+    unprivilegedJunkScopeOptions.invisibleToDebugger = true;
+    rv = CreateSandboxObject(cx, &v, nullptr, unprivilegedJunkScopeOptions);
+    MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
+    mUnprivilegedJunkScope = js::UncheckedUnwrap(&v.toObject());
+
+    // Create the Privileged Junk Scope.
+    SandboxOptions privilegedJunkScopeOptions;
+    privilegedJunkScopeOptions.sandboxName.AssignLiteral("XPConnect Privileged Junk Compartment");
+    privilegedJunkScopeOptions.invisibleToDebugger = true;
+    privilegedJunkScopeOptions.wantComponents = false;
+    rv = CreateSandboxObject(cx, &v, nsXPConnect::SystemPrincipal(), privilegedJunkScopeOptions);
+    MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
+    mPrivilegedJunkScope = js::UncheckedUnwrap(&v.toObject());
+
+    // Create the Compilation Scope.
+    SandboxOptions compilationScopeOptions;
+    compilationScopeOptions.sandboxName.AssignLiteral("XPConnect Compilation Compartment");
+    compilationScopeOptions.invisibleToDebugger = true;
+    compilationScopeOptions.discardSource = ShouldDiscardSystemSource();
+    rv = CreateSandboxObject(cx, &v, /* principal = */ nullptr, compilationScopeOptions);
+    MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
+    mCompilationScope = js::UncheckedUnwrap(&v.toObject());
+}
+
+void
+XPCJSContext::DeleteSingletonScopes()
+{
+    mUnprivilegedJunkScope = nullptr;
+    mPrivilegedJunkScope = nullptr;
+    mCompilationScope = nullptr;
+}
diff --git a/js/xpconnect/src/XPCJSID.cpp b/js/xpconnect/src/XPCJSID.cpp
new file mode 100644
index 000000000..b9cbee7be
--- /dev/null
+++ b/js/xpconnect/src/XPCJSID.cpp
@@ -0,0 +1,816 @@
+/* -*- 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/. */
+
+/* An xpcom implementation of the JavaScript nsIID and nsCID objects. */
+
+#include "xpcprivate.h"
+#include "xpc_make_class.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
+#include "mozilla/StaticPtr.h"
+
+using namespace mozilla::dom;
+using namespace JS;
+
+/***************************************************************************/
+// nsJSID
+
+NS_IMPL_CLASSINFO(nsJSID, nullptr, 0, NS_JS_ID_CID)
+NS_IMPL_ISUPPORTS_CI(nsJSID, nsIJSID)
+
+const char nsJSID::gNoString[] = "";
+
+nsJSID::nsJSID()
+    : mID(GetInvalidIID()),
+      mNumber(const_cast<char*>(gNoString)),
+      mName(const_cast<char*>(gNoString))
+{
+}
+
+nsJSID::~nsJSID()
+{
+    if (mNumber && mNumber != gNoString)
+        free(mNumber);
+    if (mName && mName != gNoString)
+        free(mName);
+}
+
+void nsJSID::Reset()
+{
+    mID = GetInvalidIID();
+
+    if (mNumber && mNumber != gNoString)
+        free(mNumber);
+    if (mName && mName != gNoString)
+        free(mName);
+
+    mNumber = mName = nullptr;
+}
+
+bool
+nsJSID::SetName(const char* name)
+{
+    MOZ_ASSERT(!mName || mName == gNoString ,"name already set");
+    MOZ_ASSERT(name,"null name");
+    mName = NS_strdup(name);
+    return mName ? true : false;
+}
+
+NS_IMETHODIMP
+nsJSID::GetName(char * *aName)
+{
+    if (!aName)
+        return NS_ERROR_NULL_POINTER;
+
+    if (!NameIsSet())
+        SetNameToNoString();
+    MOZ_ASSERT(mName, "name not set");
+    *aName = NS_strdup(mName);
+    return *aName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsJSID::GetNumber(char * *aNumber)
+{
+    if (!aNumber)
+        return NS_ERROR_NULL_POINTER;
+
+    if (!mNumber) {
+        if (!(mNumber = mID.ToString()))
+            mNumber = const_cast<char*>(gNoString);
+    }
+
+    *aNumber = NS_strdup(mNumber);
+    return *aNumber ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP_(const nsID*)
+nsJSID::GetID()
+{
+    return &mID;
+}
+
+NS_IMETHODIMP
+nsJSID::GetValid(bool* aValid)
+{
+    if (!aValid)
+        return NS_ERROR_NULL_POINTER;
+
+    *aValid = IsValid();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJSID::Equals(nsIJSID* other, bool* _retval)
+{
+    if (!_retval)
+        return NS_ERROR_NULL_POINTER;
+
+    if (!other || mID.Equals(GetInvalidIID())) {
+        *_retval = false;
+        return NS_OK;
+    }
+
+    *_retval = other->GetID()->Equals(mID);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJSID::Initialize(const char* idString)
+{
+    if (!idString)
+        return NS_ERROR_NULL_POINTER;
+
+    if (*idString != '\0' && mID.Equals(GetInvalidIID())) {
+        Reset();
+
+        if (idString[0] == '{') {
+            if (mID.Parse(idString)) {
+                return NS_OK;
+            }
+
+            // error - reset to invalid state
+            mID = GetInvalidIID();
+        }
+    }
+    return NS_ERROR_FAILURE;
+}
+
+bool
+nsJSID::InitWithName(const nsID& id, const char* nameString)
+{
+    MOZ_ASSERT(nameString, "no name");
+    Reset();
+    mID = id;
+    return SetName(nameString);
+}
+
+// try to use the name, if no name, then use the number
+NS_IMETHODIMP
+nsJSID::ToString(char** _retval)
+{
+    if (mName && mName != gNoString)
+        return GetName(_retval);
+
+    return GetNumber(_retval);
+}
+
+const nsID&
+nsJSID::GetInvalidIID() const
+{
+    // {BB1F47B0-D137-11d2-9841-006008962422}
+    static const nsID invalid = {0xbb1f47b0, 0xd137, 0x11d2,
+                                  {0x98, 0x41, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22}};
+    return invalid;
+}
+
+//static
+already_AddRefed<nsJSID>
+nsJSID::NewID(const char* str)
+{
+    if (!str) {
+        NS_ERROR("no string");
+        return nullptr;
+    }
+
+    RefPtr<nsJSID> idObj = new nsJSID();
+    NS_ENSURE_SUCCESS(idObj->Initialize(str), nullptr);
+    return idObj.forget();
+}
+
+//static
+already_AddRefed<nsJSID>
+nsJSID::NewID(const nsID& id)
+{
+    RefPtr<nsJSID> idObj = new nsJSID();
+    idObj->mID = id;
+    idObj->mName = nullptr;
+    idObj->mNumber = nullptr;
+    return idObj.forget();
+}
+
+
+/***************************************************************************/
+// Class object support so that we can share prototypes of wrapper
+
+// This class exists just so we can have a shared scriptable helper for
+// the nsJSIID class. The instances implement their own helpers. But we
+// needed to be able to indicate to the shared prototypes this single flag:
+// nsIXPCScriptable::DONT_ENUM_STATIC_PROPS. And having a class to do it is
+// the only means we have. Setting this flag on any given instance scriptable
+// helper is not sufficient to convey the information that we don't want
+// static properties enumerated on the shared proto.
+
+class SharedScriptableHelperForJSIID final : public nsIXPCScriptable
+{
+    ~SharedScriptableHelperForJSIID() {}
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCSCRIPTABLE
+    SharedScriptableHelperForJSIID() {}
+};
+
+NS_INTERFACE_MAP_BEGIN(SharedScriptableHelperForJSIID)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCScriptable)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(SharedScriptableHelperForJSIID)
+NS_IMPL_RELEASE(SharedScriptableHelperForJSIID)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           SharedScriptableHelperForJSIID
+#define XPC_MAP_QUOTED_CLASSNAME   "JSIID"
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+static mozilla::StaticRefPtr<nsIXPCScriptable> gSharedScriptableHelperForJSIID;
+static bool gClassObjectsWereInited = false;
+
+static void EnsureClassObjectsInitialized()
+{
+    if (!gClassObjectsWereInited) {
+        gSharedScriptableHelperForJSIID = new SharedScriptableHelperForJSIID();
+
+        gClassObjectsWereInited = true;
+    }
+}
+
+static nsresult GetSharedScriptableHelperForJSIID(nsIXPCScriptable** helper)
+{
+    EnsureClassObjectsInitialized();
+    nsCOMPtr<nsIXPCScriptable> temp = gSharedScriptableHelperForJSIID.get();
+    temp.forget(helper);
+    return NS_OK;
+}
+
+/******************************************************/
+
+#define NULL_CID                                                              \
+{ 0x00000000, 0x0000, 0x0000,                                                 \
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
+
+// We pass nsIClassInfo::DOM_OBJECT so that nsJSIID instances may be created
+// in unprivileged scopes.
+NS_DECL_CI_INTERFACE_GETTER(nsJSIID)
+NS_IMPL_CLASSINFO(nsJSIID, GetSharedScriptableHelperForJSIID,
+                  nsIClassInfo::DOM_OBJECT, NULL_CID)
+
+NS_DECL_CI_INTERFACE_GETTER(nsJSCID)
+NS_IMPL_CLASSINFO(nsJSCID, nullptr, 0, NULL_CID)
+
+void xpc_DestroyJSxIDClassObjects()
+{
+    if (gClassObjectsWereInited) {
+        NS_IF_RELEASE(NS_CLASSINFO_NAME(nsJSIID));
+        NS_IF_RELEASE(NS_CLASSINFO_NAME(nsJSCID));
+        gSharedScriptableHelperForJSIID = nullptr;
+
+        gClassObjectsWereInited = false;
+    }
+}
+
+/***************************************************************************/
+
+NS_INTERFACE_MAP_BEGIN(nsJSIID)
+  NS_INTERFACE_MAP_ENTRY(nsIJSID)
+  NS_INTERFACE_MAP_ENTRY(nsIJSIID)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIJSID)
+  NS_IMPL_QUERY_CLASSINFO(nsJSIID)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsJSIID)
+NS_IMPL_RELEASE(nsJSIID)
+NS_IMPL_CI_INTERFACE_GETTER(nsJSIID, nsIJSID, nsIJSIID)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsJSIID
+#define XPC_MAP_QUOTED_CLASSNAME   "nsJSIID"
+#define                             XPC_MAP_WANT_RESOLVE
+#define                             XPC_MAP_WANT_ENUMERATE
+#define                             XPC_MAP_WANT_HASINSTANCE
+#define XPC_MAP_FLAGS               nsIXPCScriptable::ALLOW_PROP_MODS_DURING_RESOLVE
+#include "xpc_map_end.h" /* This will #undef the above */
+
+
+nsJSIID::nsJSIID(nsIInterfaceInfo* aInfo)
+    : mInfo(aInfo)
+{
+}
+
+nsJSIID::~nsJSIID() {}
+
+// If mInfo is present we use it and ignore mDetails, else we use mDetails.
+
+NS_IMETHODIMP nsJSIID::GetName(char * *aName)
+{
+    return mInfo->GetName(aName);
+}
+
+NS_IMETHODIMP nsJSIID::GetNumber(char * *aNumber)
+{
+    char str[NSID_LENGTH];
+    const nsIID* id;
+    mInfo->GetIIDShared(&id);
+    id->ToProvidedString(str);
+    *aNumber = (char*) nsMemory::Clone(str, NSID_LENGTH);
+    return *aNumber ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP_(const nsID*) nsJSIID::GetID()
+{
+    const nsIID* id;
+    mInfo->GetIIDShared(&id);
+    return id;
+}
+
+NS_IMETHODIMP nsJSIID::GetValid(bool* aValid)
+{
+    *aValid = true;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsJSIID::Equals(nsIJSID* other, bool* _retval)
+{
+    if (!_retval)
+        return NS_ERROR_NULL_POINTER;
+
+    if (!other) {
+        *_retval = false;
+        return NS_OK;
+    }
+
+    mInfo->IsIID(other->GetID(), _retval);
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsJSIID::Initialize(const char* idString)
+{
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsJSIID::ToString(char** _retval)
+{
+    return mInfo->GetName(_retval);
+}
+
+// static
+already_AddRefed<nsJSIID>
+nsJSIID::NewID(nsIInterfaceInfo* aInfo)
+{
+    if (!aInfo) {
+        NS_ERROR("no info");
+        return nullptr;
+    }
+
+    bool canScript;
+    if (NS_FAILED(aInfo->IsScriptable(&canScript)) || !canScript)
+        return nullptr;
+
+    RefPtr<nsJSIID> idObj = new nsJSIID(aInfo);
+    return idObj.forget();
+}
+
+
+NS_IMETHODIMP
+nsJSIID::Resolve(nsIXPConnectWrappedNative* wrapper,
+                 JSContext * cx, JSObject * objArg,
+                 jsid idArg, bool* resolvedp,
+                 bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    RootedId id(cx, idArg);
+    XPCCallContext ccx(cx);
+
+    RefPtr<XPCNativeInterface> iface =
+        XPCNativeInterface::GetNewOrUsed(mInfo);
+
+    if (!iface)
+        return NS_OK;
+
+    XPCNativeMember* member = iface->FindMember(id);
+    if (member && member->IsConstant()) {
+        RootedValue val(cx);
+        if (!member->GetConstantValue(ccx, iface, val.address()))
+            return NS_ERROR_OUT_OF_MEMORY;
+
+        *resolvedp = true;
+        *_retval = JS_DefinePropertyById(cx, obj, id, val,
+                                         JSPROP_ENUMERATE | JSPROP_READONLY |
+                                         JSPROP_PERMANENT | JSPROP_RESOLVING);
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJSIID::Enumerate(nsIXPConnectWrappedNative* wrapper,
+                   JSContext * cx, JSObject * objArg, bool* _retval)
+{
+    // In this case, let's just eagerly resolve...
+
+    RootedObject obj(cx, objArg);
+    XPCCallContext ccx(cx);
+
+    RefPtr<XPCNativeInterface> iface =
+        XPCNativeInterface::GetNewOrUsed(mInfo);
+
+    if (!iface)
+        return NS_OK;
+
+    uint16_t count = iface->GetMemberCount();
+    for (uint16_t i = 0; i < count; i++) {
+        XPCNativeMember* member = iface->GetMemberAt(i);
+        if (member && member->IsConstant() &&
+            !xpc_ForcePropertyResolve(cx, obj, member->GetName())) {
+            return NS_ERROR_UNEXPECTED;
+        }
+    }
+    return NS_OK;
+}
+
+/*
+ * HasInstance hooks need to find an appropriate reflector in order to function
+ * properly. There are two complexities that we need to handle:
+ *
+ * 1 - Cross-compartment wrappers. Chrome uses over 100 compartments, all with
+ *     system principal. The success of an instanceof check should not depend
+ *     on which compartment an object comes from. At the same time, we want to
+ *     make sure we don't unwrap important security wrappers.
+ *     CheckedUnwrap does the right thing here.
+ *
+ * 2 - Prototype chains. Suppose someone creates a vanilla JS object |a| and
+ *     sets its __proto__ to some WN |b|. If |b instanceof nsIFoo| returns true,
+ *     one would expect |a instanceof nsIFoo| to return true as well, since
+ *     instanceof is transitive up the prototype chain in ECMAScript. Moreover,
+ *     there's chrome code that relies on this.
+ *
+ * This static method handles both complexities, returning either an XPCWN, a
+ * DOM object, or null. The object may well be cross-compartment from |cx|.
+ */
+static nsresult
+FindObjectForHasInstance(JSContext* cx, HandleObject objArg, MutableHandleObject target)
+{
+    RootedObject obj(cx, objArg), proto(cx);
+
+    while (obj && !IS_WN_REFLECTOR(obj) &&
+           !IsDOMObject(obj) && !mozilla::jsipc::IsCPOW(obj))
+    {
+        if (js::IsWrapper(obj)) {
+            obj = js::CheckedUnwrap(obj, /* stopAtWindowProxy = */ false);
+            continue;
+        }
+
+        {
+            JSAutoCompartment ac(cx, obj);
+            if (!js::GetObjectProto(cx, obj, &proto))
+                return NS_ERROR_FAILURE;
+        }
+
+        obj = proto;
+    }
+
+    target.set(obj);
+    return NS_OK;
+}
+
+nsresult
+xpc::HasInstance(JSContext* cx, HandleObject objArg, const nsID* iid, bool* bp)
+{
+    *bp = false;
+
+    RootedObject obj(cx);
+    nsresult rv = FindObjectForHasInstance(cx, objArg, &obj);
+    if (NS_WARN_IF(NS_FAILED(rv)))
+        return rv;
+
+    if (!obj)
+        return NS_OK;
+
+    if (mozilla::jsipc::IsCPOW(obj))
+        return mozilla::jsipc::InstanceOf(obj, iid, bp);
+
+    nsCOMPtr<nsISupports> identity = UnwrapReflectorToISupports(obj);
+    if (!identity)
+        return NS_OK;
+
+    nsCOMPtr<nsISupports> supp;
+    identity->QueryInterface(*iid, getter_AddRefs(supp));
+    *bp = supp;
+
+    // Our old HasInstance implementation operated by invoking FindTearOff on
+    // XPCWrappedNatives, and various bits of chrome JS came to depend on
+    // |instanceof| doing an implicit QI if it succeeds. Do a drive-by QI to
+    // preserve that behavior. This is just a compatibility hack, so we don't
+    // really care if it fails.
+    if (IS_WN_REFLECTOR(obj))
+        (void) XPCWrappedNative::Get(obj)->FindTearOff(*iid);
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJSIID::HasInstance(nsIXPConnectWrappedNative* wrapper,
+                     JSContext* cx, JSObject * /* unused */,
+                     HandleValue val, bool* bp, bool* _retval)
+{
+    *bp = false;
+
+    if (val.isPrimitive())
+        return NS_OK;
+
+    // we have a JSObject
+    RootedObject obj(cx, &val.toObject());
+
+    const nsIID* iid;
+    mInfo->GetIIDShared(&iid);
+    return xpc::HasInstance(cx, obj, iid, bp);
+}
+
+/***************************************************************************/
+
+NS_INTERFACE_MAP_BEGIN(nsJSCID)
+  NS_INTERFACE_MAP_ENTRY(nsIJSID)
+  NS_INTERFACE_MAP_ENTRY(nsIJSCID)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIJSID)
+  NS_IMPL_QUERY_CLASSINFO(nsJSCID)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(nsJSCID)
+NS_IMPL_RELEASE(nsJSCID)
+NS_IMPL_CI_INTERFACE_GETTER(nsJSCID, nsIJSID, nsIJSCID)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           nsJSCID
+#define XPC_MAP_QUOTED_CLASSNAME   "nsJSCID"
+#define                             XPC_MAP_WANT_CONSTRUCT
+#define                             XPC_MAP_WANT_HASINSTANCE
+#define XPC_MAP_FLAGS               0
+#include "xpc_map_end.h" /* This will #undef the above */
+
+nsJSCID::nsJSCID()  { mDetails = new nsJSID(); }
+nsJSCID::~nsJSCID() {}
+
+NS_IMETHODIMP nsJSCID::GetName(char * *aName)
+    {ResolveName(); return mDetails->GetName(aName);}
+
+NS_IMETHODIMP nsJSCID::GetNumber(char * *aNumber)
+    {return mDetails->GetNumber(aNumber);}
+
+NS_IMETHODIMP_(const nsID*) nsJSCID::GetID()
+    {return &mDetails->ID();}
+
+NS_IMETHODIMP nsJSCID::GetValid(bool* aValid)
+    {return mDetails->GetValid(aValid);}
+
+NS_IMETHODIMP nsJSCID::Equals(nsIJSID* other, bool* _retval)
+    {return mDetails->Equals(other, _retval);}
+
+NS_IMETHODIMP nsJSCID::Initialize(const char* idString)
+    {return mDetails->Initialize(idString);}
+
+NS_IMETHODIMP nsJSCID::ToString(char** _retval)
+    {ResolveName(); return mDetails->ToString(_retval);}
+
+void
+nsJSCID::ResolveName()
+{
+    if (!mDetails->NameIsSet())
+        mDetails->SetNameToNoString();
+}
+
+//static
+already_AddRefed<nsJSCID>
+nsJSCID::NewID(const char* str)
+{
+    if (!str) {
+        NS_ERROR("no string");
+        return nullptr;
+    }
+
+    RefPtr<nsJSCID> idObj = new nsJSCID();
+    if (str[0] == '{') {
+        NS_ENSURE_SUCCESS(idObj->Initialize(str), nullptr);
+    } else {
+        nsCOMPtr<nsIComponentRegistrar> registrar;
+        NS_GetComponentRegistrar(getter_AddRefs(registrar));
+        NS_ENSURE_TRUE(registrar, nullptr);
+
+        nsCID* cid;
+        if (NS_FAILED(registrar->ContractIDToCID(str, &cid)))
+            return nullptr;
+        bool success = idObj->mDetails->InitWithName(*cid, str);
+        free(cid);
+        if (!success)
+            return nullptr;
+    }
+    return idObj.forget();
+}
+
+static const nsID*
+GetIIDArg(uint32_t argc, const JS::Value& val, JSContext* cx)
+{
+    const nsID* iid;
+
+    // If an IID was passed in then use it
+    if (argc) {
+        JSObject* iidobj;
+        if (val.isPrimitive() ||
+            !(iidobj = val.toObjectOrNull()) ||
+            !(iid = xpc_JSObjectToID(cx, iidobj))) {
+            return nullptr;
+        }
+    } else
+        iid = &NS_GET_IID(nsISupports);
+
+    return iid;
+}
+
+NS_IMETHODIMP
+nsJSCID::CreateInstance(HandleValue iidval, JSContext* cx,
+                        uint8_t optionalArgc, MutableHandleValue retval)
+{
+    if (!mDetails->IsValid())
+        return NS_ERROR_XPC_BAD_CID;
+
+    if (NS_FAILED(nsXPConnect::SecurityManager()->CanCreateInstance(cx, mDetails->ID()))) {
+        NS_ERROR("how are we not being called from chrome here?");
+        return NS_OK;
+    }
+
+    // If an IID was passed in then use it
+    const nsID* iid = GetIIDArg(optionalArgc, iidval, cx);
+    if (!iid)
+        return NS_ERROR_XPC_BAD_IID;
+
+    nsCOMPtr<nsIComponentManager> compMgr;
+    nsresult rv = NS_GetComponentManager(getter_AddRefs(compMgr));
+    if (NS_FAILED(rv))
+        return NS_ERROR_UNEXPECTED;
+
+    nsCOMPtr<nsISupports> inst;
+    rv = compMgr->CreateInstance(mDetails->ID(), nullptr, *iid, getter_AddRefs(inst));
+    MOZ_ASSERT(NS_FAILED(rv) || inst, "component manager returned success, but instance is null!");
+
+    if (NS_FAILED(rv) || !inst)
+        return NS_ERROR_XPC_CI_RETURNED_FAILURE;
+
+    rv = nsContentUtils::WrapNative(cx, inst, iid, retval);
+    if (NS_FAILED(rv) || retval.isPrimitive())
+        return NS_ERROR_XPC_CANT_CREATE_WN;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJSCID::GetService(HandleValue iidval, JSContext* cx, uint8_t optionalArgc,
+                    MutableHandleValue retval)
+{
+    if (!mDetails->IsValid())
+        return NS_ERROR_XPC_BAD_CID;
+
+    if (NS_FAILED(nsXPConnect::SecurityManager()->CanCreateInstance(cx, mDetails->ID()))) {
+        MOZ_ASSERT(JS_IsExceptionPending(cx),
+                   "security manager vetoed GetService without setting exception");
+        return NS_OK;
+    }
+
+    // If an IID was passed in then use it
+    const nsID* iid = GetIIDArg(optionalArgc, iidval, cx);
+    if (!iid)
+        return NS_ERROR_XPC_BAD_IID;
+
+    nsCOMPtr<nsIServiceManager> svcMgr;
+    nsresult rv = NS_GetServiceManager(getter_AddRefs(svcMgr));
+    if (NS_FAILED(rv))
+        return rv;
+
+    nsCOMPtr<nsISupports> srvc;
+    rv = svcMgr->GetService(mDetails->ID(), *iid, getter_AddRefs(srvc));
+    MOZ_ASSERT(NS_FAILED(rv) || srvc, "service manager returned success, but service is null!");
+    if (NS_FAILED(rv) || !srvc)
+        return NS_ERROR_XPC_GS_RETURNED_FAILURE;
+
+    RootedValue v(cx);
+    rv = nsContentUtils::WrapNative(cx, srvc, iid, &v);
+    if (NS_FAILED(rv) || !v.isObject())
+        return NS_ERROR_XPC_CANT_CREATE_WN;
+
+    retval.set(v);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJSCID::Construct(nsIXPConnectWrappedNative* wrapper,
+                   JSContext* cx, JSObject* objArg,
+                   const CallArgs& args, bool* _retval)
+{
+    RootedObject obj(cx, objArg);
+    XPCJSContext* xpccx = nsXPConnect::GetContextInstance();
+    if (!xpccx)
+        return NS_ERROR_FAILURE;
+
+    // 'push' a call context and call on it
+    RootedId name(cx, xpccx->GetStringID(XPCJSContext::IDX_CREATE_INSTANCE));
+    XPCCallContext ccx(cx, obj, nullptr, name, args.length(), args.array(),
+                       args.rval().address());
+
+    *_retval = XPCWrappedNative::CallMethod(ccx);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsJSCID::HasInstance(nsIXPConnectWrappedNative* wrapper,
+                     JSContext* cx, JSObject * /* unused */,
+                     HandleValue val, bool* bp, bool* _retval)
+{
+    *bp = false;
+
+    if (!val.isObject())
+        return NS_OK;
+
+    RootedObject obj(cx, &val.toObject());
+
+    // is this really a native xpcom object with a wrapper?
+    RootedObject target(cx);
+    nsresult rv = FindObjectForHasInstance(cx, obj, &target);
+    if (NS_WARN_IF(NS_FAILED(rv)))
+        return rv;
+
+    if (!target || !IS_WN_REFLECTOR(target))
+        return NS_OK;
+
+    if (XPCWrappedNative* other_wrapper = XPCWrappedNative::Get(target)) {
+        if (nsIClassInfo* ci = other_wrapper->GetClassInfo()) {
+            // We consider CID equality to be the thing that matters here.
+            // This is perhaps debatable.
+            nsID cid;
+            if (NS_SUCCEEDED(ci->GetClassIDNoAlloc(&cid)))
+                *bp = cid.Equals(mDetails->ID());
+        }
+    }
+
+    return NS_OK;
+}
+
+/***************************************************************************/
+// additional utilities...
+
+JSObject*
+xpc_NewIDObject(JSContext* cx, HandleObject jsobj, const nsID& aID)
+{
+    RootedObject obj(cx);
+
+    nsCOMPtr<nsIJSID> iid = nsJSID::NewID(aID);
+    if (iid) {
+        nsXPConnect* xpc = nsXPConnect::XPConnect();
+        if (xpc) {
+            xpc->WrapNative(cx, jsobj, static_cast<nsISupports*>(iid),
+                            NS_GET_IID(nsIJSID), obj.address());
+        }
+    }
+    return obj;
+}
+
+// note: returned pointer is only valid while |obj| remains alive!
+const nsID*
+xpc_JSObjectToID(JSContext* cx, JSObject* obj)
+{
+    if (!cx || !obj)
+        return nullptr;
+
+    // NOTE: this call does NOT addref
+    XPCWrappedNative* wrapper = nullptr;
+    obj = js::CheckedUnwrap(obj);
+    if (obj && IS_WN_REFLECTOR(obj))
+        wrapper = XPCWrappedNative::Get(obj);
+    if (wrapper &&
+        (wrapper->HasInterfaceNoQI(NS_GET_IID(nsIJSID))  ||
+         wrapper->HasInterfaceNoQI(NS_GET_IID(nsIJSIID)) ||
+         wrapper->HasInterfaceNoQI(NS_GET_IID(nsIJSCID)))) {
+        return ((nsIJSID*)wrapper->GetIdentityObject())->GetID();
+    }
+    return nullptr;
+}
+
+bool
+xpc_JSObjectIsID(JSContext* cx, JSObject* obj)
+{
+    MOZ_ASSERT(cx && obj, "bad param");
+    // NOTE: this call does NOT addref
+    XPCWrappedNative* wrapper = nullptr;
+    obj = js::CheckedUnwrap(obj);
+    if (obj && IS_WN_REFLECTOR(obj))
+        wrapper = XPCWrappedNative::Get(obj);
+    return wrapper &&
+           (wrapper->HasInterfaceNoQI(NS_GET_IID(nsIJSID))  ||
+            wrapper->HasInterfaceNoQI(NS_GET_IID(nsIJSIID)) ||
+            wrapper->HasInterfaceNoQI(NS_GET_IID(nsIJSCID)));
+}
+
+
diff --git a/js/xpconnect/src/XPCJSMemoryReporter.h b/js/xpconnect/src/XPCJSMemoryReporter.h
new file mode 100644
index 000000000..7881ac0f5
--- /dev/null
+++ b/js/xpconnect/src/XPCJSMemoryReporter.h
@@ -0,0 +1,33 @@
+/* -*- 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/. */
+
+#ifndef XPCJSMemoryReporter_h
+#define XPCJSMemoryReporter_h
+
+class nsISupports;
+class nsIMemoryReporterCallback;
+
+namespace xpc {
+
+// The key is the window ID.
+typedef nsDataHashtable<nsUint64HashKey, nsCString> WindowPaths;
+
+// This is very nearly an instance of nsIMemoryReporter, but it's not,
+// because it's invoked by nsWindowMemoryReporter in order to get |windowPaths|
+// in CollectReports.
+class JSReporter
+{
+public:
+    static void CollectReports(WindowPaths* windowPaths,
+                               WindowPaths* topWindowPaths,
+                               nsIMemoryReporterCallback* handleReport,
+                               nsISupports* data,
+                               bool anonymize);
+};
+
+} // namespace xpc
+
+#endif
diff --git a/js/xpconnect/src/XPCJSWeakReference.cpp b/js/xpconnect/src/XPCJSWeakReference.cpp
new file mode 100644
index 000000000..bd7c80bc0
--- /dev/null
+++ b/js/xpconnect/src/XPCJSWeakReference.cpp
@@ -0,0 +1,94 @@
+/* -*- 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 "xpcprivate.h"
+#include "XPCJSWeakReference.h"
+
+#include "nsContentUtils.h"
+
+using namespace JS;
+
+xpcJSWeakReference::xpcJSWeakReference()
+{
+}
+
+NS_IMPL_ISUPPORTS(xpcJSWeakReference, xpcIJSWeakReference)
+
+nsresult xpcJSWeakReference::Init(JSContext* cx, const JS::Value& object)
+{
+    if (!object.isObject())
+        return NS_OK;
+
+    JS::RootedObject obj(cx, &object.toObject());
+
+    XPCCallContext ccx(cx);
+
+    // See if the object is a wrapped native that supports weak references.
+    nsCOMPtr<nsISupports> supports = xpc::UnwrapReflectorToISupports(obj);
+    nsCOMPtr<nsISupportsWeakReference> supportsWeakRef =
+        do_QueryInterface(supports);
+    if (supportsWeakRef) {
+        supportsWeakRef->GetWeakReference(getter_AddRefs(mReferent));
+        if (mReferent) {
+            return NS_OK;
+        }
+    }
+    // If it's not a wrapped native, or it is a wrapped native that does not
+    // support weak references, fall back to getting a weak ref to the object.
+
+    // See if object is a wrapped JSObject.
+    RefPtr<nsXPCWrappedJS> wrapped;
+    nsresult rv = nsXPCWrappedJS::GetNewOrUsed(obj,
+                                               NS_GET_IID(nsISupports),
+                                               getter_AddRefs(wrapped));
+    if (!wrapped) {
+        NS_ERROR("can't get nsISupportsWeakReference wrapper for obj");
+        return rv;
+    }
+
+    return wrapped->GetWeakReference(getter_AddRefs(mReferent));
+}
+
+NS_IMETHODIMP
+xpcJSWeakReference::Get(JSContext* aCx, MutableHandleValue aRetval)
+{
+    aRetval.setNull();
+
+    if (!mReferent) {
+        return NS_OK;
+    }
+
+    nsCOMPtr<nsISupports> supports = do_QueryReferent(mReferent);
+    if (!supports) {
+        return NS_OK;
+    }
+
+    nsCOMPtr<nsIXPConnectWrappedJS> wrappedObj = do_QueryInterface(supports);
+    if (!wrappedObj) {
+        // We have a generic XPCOM object that supports weak references here.
+        // Wrap it and pass it out.
+        return nsContentUtils::WrapNative(aCx, supports,
+                                          &NS_GET_IID(nsISupports),
+                                          aRetval);
+    }
+
+    JS::RootedObject obj(aCx, wrappedObj->GetJSObject());
+    if (!obj) {
+        return NS_OK;
+    }
+
+    // Most users of XPCWrappedJS don't need to worry about
+    // re-wrapping because things are implicitly rewrapped by
+    // xpcconvert. However, because we're doing this directly
+    // through the native call context, we need to call
+    // JS_WrapObject().
+    if (!JS_WrapObject(aCx, &obj)) {
+        return NS_ERROR_FAILURE;
+    }
+
+    aRetval.setObject(*obj);
+    return NS_OK;
+}
diff --git a/js/xpconnect/src/XPCJSWeakReference.h b/js/xpconnect/src/XPCJSWeakReference.h
new file mode 100644
index 000000000..ba802044f
--- /dev/null
+++ b/js/xpconnect/src/XPCJSWeakReference.h
@@ -0,0 +1,29 @@
+/* -*- 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/. */
+
+#ifndef xpcjsweakreference_h___
+#define xpcjsweakreference_h___
+
+#include "xpcIJSWeakReference.h"
+#include "nsIWeakReference.h"
+#include "mozilla/Attributes.h"
+
+class xpcJSWeakReference final : public xpcIJSWeakReference
+{
+    ~xpcJSWeakReference() {}
+
+public:
+    xpcJSWeakReference();
+    nsresult Init(JSContext* cx, const JS::Value& object);
+
+    NS_DECL_ISUPPORTS
+    NS_DECL_XPCIJSWEAKREFERENCE
+
+private:
+    nsCOMPtr<nsIWeakReference> mReferent;
+};
+
+#endif // xpcjsweakreference_h___
diff --git a/js/xpconnect/src/XPCLocale.cpp b/js/xpconnect/src/XPCLocale.cpp
new file mode 100644
index 000000000..2fe78cb75
--- /dev/null
+++ b/js/xpconnect/src/XPCLocale.cpp
@@ -0,0 +1,289 @@
+/* -*- 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/Assertions.h"
+
+#include "jsapi.h"
+
+#include "nsCollationCID.h"
+#include "nsJSUtils.h"
+#include "nsIPlatformCharset.h"
+#include "nsILocaleService.h"
+#include "nsICollation.h"
+#include "nsUnicharUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/dom/EncodingUtils.h"
+#include "mozilla/Preferences.h"
+#include "nsIUnicodeDecoder.h"
+
+#include "xpcpublic.h"
+
+using namespace JS;
+using mozilla::dom::EncodingUtils;
+
+/**
+ * JS locale callbacks implemented by XPCOM modules.  These are theoretically
+ * safe for use on multiple threads.  Unfortunately, the intl code underlying
+ * these XPCOM modules doesn't yet support this, so in practice
+ * XPCLocaleCallbacks are limited to the main thread.
+ */
+struct XPCLocaleCallbacks : public JSLocaleCallbacks
+{
+  XPCLocaleCallbacks()
+#ifdef DEBUG
+    : mThread(PR_GetCurrentThread())
+#endif
+  {
+    MOZ_COUNT_CTOR(XPCLocaleCallbacks);
+
+    localeToUpperCase = LocaleToUpperCase;
+    localeToLowerCase = LocaleToLowerCase;
+    localeCompare = LocaleCompare;
+    localeToUnicode = LocaleToUnicode;
+  }
+
+  ~XPCLocaleCallbacks()
+  {
+    AssertThreadSafety();
+    MOZ_COUNT_DTOR(XPCLocaleCallbacks);
+  }
+
+  /**
+   * Return the XPCLocaleCallbacks that's hidden away in |cx|. (This impl uses
+   * the locale callbacks struct to store away its per-context data.)
+   */
+  static XPCLocaleCallbacks*
+  This(JSContext* cx)
+  {
+    // Locale information for |cx| was associated using xpc_LocalizeContext;
+    // assert and double-check this.
+    const JSLocaleCallbacks* lc = JS_GetLocaleCallbacks(cx);
+    MOZ_ASSERT(lc);
+    MOZ_ASSERT(lc->localeToUpperCase == LocaleToUpperCase);
+    MOZ_ASSERT(lc->localeToLowerCase == LocaleToLowerCase);
+    MOZ_ASSERT(lc->localeCompare == LocaleCompare);
+    MOZ_ASSERT(lc->localeToUnicode == LocaleToUnicode);
+
+    const XPCLocaleCallbacks* ths = static_cast<const XPCLocaleCallbacks*>(lc);
+    ths->AssertThreadSafety();
+    return const_cast<XPCLocaleCallbacks*>(ths);
+  }
+
+  static bool
+  LocaleToUpperCase(JSContext* cx, HandleString src, MutableHandleValue rval)
+  {
+    return ChangeCase(cx, src, rval, ToUpperCase);
+  }
+
+  static bool
+  LocaleToLowerCase(JSContext* cx, HandleString src, MutableHandleValue rval)
+  {
+    return ChangeCase(cx, src, rval, ToLowerCase);
+  }
+
+  static bool
+  LocaleToUnicode(JSContext* cx, const char* src, MutableHandleValue rval)
+  {
+    return This(cx)->ToUnicode(cx, src, rval);
+  }
+
+  static bool
+  LocaleCompare(JSContext* cx, HandleString src1, HandleString src2, MutableHandleValue rval)
+  {
+    return This(cx)->Compare(cx, src1, src2, rval);
+  }
+
+private:
+  static bool
+  ChangeCase(JSContext* cx, HandleString src, MutableHandleValue rval,
+             void(*changeCaseFnc)(const nsAString&, nsAString&))
+  {
+    nsAutoJSString autoStr;
+    if (!autoStr.init(cx, src)) {
+      return false;
+    }
+
+    nsAutoString result;
+    changeCaseFnc(autoStr, result);
+
+    JSString* ucstr =
+      JS_NewUCStringCopyN(cx, result.get(), result.Length());
+    if (!ucstr) {
+      return false;
+    }
+
+    rval.setString(ucstr);
+    return true;
+  }
+
+  bool
+  Compare(JSContext* cx, HandleString src1, HandleString src2, MutableHandleValue rval)
+  {
+    nsresult rv;
+
+    if (!mCollation) {
+      nsCOMPtr<nsILocaleService> localeService =
+        do_GetService(NS_LOCALESERVICE_CONTRACTID, &rv);
+
+      if (NS_SUCCEEDED(rv)) {
+        nsCOMPtr<nsILocale> locale;
+        rv = localeService->GetApplicationLocale(getter_AddRefs(locale));
+
+        if (NS_SUCCEEDED(rv)) {
+          nsCOMPtr<nsICollationFactory> colFactory =
+            do_CreateInstance(NS_COLLATIONFACTORY_CONTRACTID, &rv);
+
+          if (NS_SUCCEEDED(rv)) {
+            rv = colFactory->CreateCollation(locale, getter_AddRefs(mCollation));
+          }
+        }
+      }
+
+      if (NS_FAILED(rv)) {
+        xpc::Throw(cx, rv);
+        return false;
+      }
+    }
+
+    nsAutoJSString autoStr1, autoStr2;
+    if (!autoStr1.init(cx, src1) || !autoStr2.init(cx, src2)) {
+      return false;
+    }
+
+    int32_t result;
+    rv = mCollation->CompareString(nsICollation::kCollationStrengthDefault,
+                                   autoStr1, autoStr2, &result);
+
+    if (NS_FAILED(rv)) {
+      xpc::Throw(cx, rv);
+      return false;
+    }
+
+    rval.setInt32(result);
+    return true;
+  }
+
+  bool
+  ToUnicode(JSContext* cx, const char* src, MutableHandleValue rval)
+  {
+    nsresult rv;
+
+    if (!mDecoder) {
+      // use app default locale
+      nsCOMPtr<nsILocaleService> localeService =
+        do_GetService(NS_LOCALESERVICE_CONTRACTID, &rv);
+      if (NS_SUCCEEDED(rv)) {
+        nsCOMPtr<nsILocale> appLocale;
+        rv = localeService->GetApplicationLocale(getter_AddRefs(appLocale));
+        if (NS_SUCCEEDED(rv)) {
+          nsAutoString localeStr;
+          rv = appLocale->
+               GetCategory(NS_LITERAL_STRING(NSILOCALE_TIME), localeStr);
+          MOZ_ASSERT(NS_SUCCEEDED(rv), "failed to get app locale info");
+
+          nsCOMPtr<nsIPlatformCharset> platformCharset =
+            do_GetService(NS_PLATFORMCHARSET_CONTRACTID, &rv);
+
+          if (NS_SUCCEEDED(rv)) {
+            nsAutoCString charset;
+            rv = platformCharset->GetDefaultCharsetForLocale(localeStr, charset);
+            if (NS_SUCCEEDED(rv)) {
+              mDecoder = EncodingUtils::DecoderForEncoding(charset);
+            }
+          }
+        }
+      }
+    }
+
+    int32_t srcLength = strlen(src);
+
+    if (mDecoder) {
+      int32_t unicharLength = srcLength;
+      char16_t* unichars =
+        (char16_t*)JS_malloc(cx, (srcLength + 1) * sizeof(char16_t));
+      if (unichars) {
+        rv = mDecoder->Convert(src, &srcLength, unichars, &unicharLength);
+        if (NS_SUCCEEDED(rv)) {
+          // terminate the returned string
+          unichars[unicharLength] = 0;
+
+          // nsIUnicodeDecoder::Convert may use fewer than srcLength PRUnichars
+          if (unicharLength + 1 < srcLength + 1) {
+            char16_t* shrunkUnichars =
+              (char16_t*)JS_realloc(cx, unichars,
+                                     (srcLength + 1) * sizeof(char16_t),
+                                     (unicharLength + 1) * sizeof(char16_t));
+            if (shrunkUnichars)
+              unichars = shrunkUnichars;
+          }
+          JSString* str = JS_NewUCString(cx, reinterpret_cast<char16_t*>(unichars), unicharLength);
+          if (str) {
+            rval.setString(str);
+            return true;
+          }
+        }
+        JS_free(cx, unichars);
+      }
+    }
+
+    xpc::Throw(cx, NS_ERROR_OUT_OF_MEMORY);
+    return false;
+  }
+
+  void AssertThreadSafety() const
+  {
+    MOZ_ASSERT(mThread == PR_GetCurrentThread(),
+               "XPCLocaleCallbacks used unsafely!");
+  }
+
+  nsCOMPtr<nsICollation> mCollation;
+  nsCOMPtr<nsIUnicodeDecoder> mDecoder;
+#ifdef DEBUG
+  PRThread* mThread;
+#endif
+};
+
+bool
+xpc_LocalizeContext(JSContext* cx)
+{
+  JS_SetLocaleCallbacks(cx, new XPCLocaleCallbacks());
+
+  // Set the default locale.
+
+  // Check a pref to see if we should use US English locale regardless
+  // of the system locale.
+  if (Preferences::GetBool("javascript.use_us_english_locale", false)) {
+    return JS_SetDefaultLocale(cx, "en-US");
+  }
+
+  // No pref has been found, so get the default locale from the
+  // application's locale.
+  nsCOMPtr<nsILocaleService> localeService =
+    do_GetService(NS_LOCALESERVICE_CONTRACTID);
+  if (!localeService)
+    return false;
+
+  nsCOMPtr<nsILocale> appLocale;
+  nsresult rv = localeService->GetApplicationLocale(getter_AddRefs(appLocale));
+  if (NS_FAILED(rv))
+    return false;
+
+  nsAutoString localeStr;
+  rv = appLocale->GetCategory(NS_LITERAL_STRING(NSILOCALE_TIME), localeStr);
+  MOZ_ASSERT(NS_SUCCEEDED(rv), "failed to get app locale info");
+  NS_LossyConvertUTF16toASCII locale(localeStr);
+
+  return JS_SetDefaultLocale(cx, locale.get());
+}
+
+void
+xpc_DelocalizeContext(JSContext* cx)
+{
+  const XPCLocaleCallbacks* lc = XPCLocaleCallbacks::This(cx);
+  JS_SetLocaleCallbacks(cx, nullptr);
+  delete lc;
+}
diff --git a/js/xpconnect/src/XPCLog.cpp b/js/xpconnect/src/XPCLog.cpp
new file mode 100644
index 000000000..515af2a47
--- /dev/null
+++ b/js/xpconnect/src/XPCLog.cpp
@@ -0,0 +1,94 @@
+/* -*- 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/. */
+
+/* Debug Logging support. */
+
+#include "XPCLog.h"
+#include "mozilla/Logging.h"
+#include "prprf.h"
+#include "mozilla/mozalloc.h"
+#include <string.h>
+#include <stdarg.h>
+
+// this all only works for DEBUG...
+#ifdef DEBUG
+
+#define SPACE_COUNT     200
+#define LINE_LEN        200
+#define INDENT_FACTOR   2
+
+#define CAN_RUN (g_InitState == 1 || (g_InitState == 0 && Init()))
+
+static char*    g_Spaces;
+static int      g_InitState = 0;
+static int      g_Indent = 0;
+static mozilla::LazyLogModule g_LogMod("xpclog");
+
+static bool Init()
+{
+    g_Spaces = new char[SPACE_COUNT+1];
+    if (!g_Spaces || !MOZ_LOG_TEST(g_LogMod,LogLevel::Error)) {
+        g_InitState = 1;
+        XPC_Log_Finish();
+        return false;
+    }
+    memset(g_Spaces, ' ', SPACE_COUNT);
+    g_Spaces[SPACE_COUNT] = 0;
+    g_InitState = 1;
+    return true;
+}
+
+void
+XPC_Log_Finish()
+{
+    if (g_InitState == 1) {
+        delete [] g_Spaces;
+    }
+    g_InitState = -1;
+}
+
+void
+XPC_Log_print(const char* fmt, ...)
+{
+    va_list ap;
+    char line[LINE_LEN];
+
+    va_start(ap, fmt);
+    PR_vsnprintf(line, sizeof(line)-1, fmt, ap);
+    va_end(ap);
+    if (g_Indent)
+        PR_LogPrint("%s%s",g_Spaces+SPACE_COUNT-(INDENT_FACTOR*g_Indent),line);
+    else
+        PR_LogPrint("%s",line);
+}
+
+bool
+XPC_Log_Check(int i)
+{
+    return CAN_RUN && MOZ_LOG_TEST(g_LogMod,LogLevel::Error);
+}
+
+void
+XPC_Log_Indent()
+{
+    if (INDENT_FACTOR*(++g_Indent) > SPACE_COUNT)
+        g_Indent-- ;
+}
+
+void
+XPC_Log_Outdent()
+{
+    if (--g_Indent < 0)
+        g_Indent++;
+}
+
+void
+XPC_Log_Clear_Indent()
+{
+    g_Indent = 0;
+}
+
+#endif
diff --git a/js/xpconnect/src/XPCLog.h b/js/xpconnect/src/XPCLog.h
new file mode 100644
index 000000000..e5f5a2cf0
--- /dev/null
+++ b/js/xpconnect/src/XPCLog.h
@@ -0,0 +1,64 @@
+/* -*- 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/. */
+
+/* Debug Logging support. */
+
+#ifndef xpclog_h___
+#define xpclog_h___
+
+#include "mozilla/Logging.h"
+
+/*
+ * This uses mozilla/Logging.h. The module name used here is 'xpclog'.
+ * These environment settings should work...
+ *
+ * SET MOZ_LOG=xpclog:5
+ * SET MOZ_LOG_FILE=logfile.txt
+ *
+ * usage:
+ *   XPC_LOG_ERROR(("my comment number %d", 5))   // note the double parens
+ *
+ */
+
+#ifdef DEBUG
+#define XPC_LOG_INTERNAL(number,_args)  \
+    do{if (XPC_Log_Check(number)){XPC_Log_print _args;}}while (0)
+
+#define XPC_LOG_ALWAYS(_args)   XPC_LOG_INTERNAL(1,_args)
+#define XPC_LOG_ERROR(_args)    XPC_LOG_INTERNAL(2,_args)
+#define XPC_LOG_WARNING(_args)  XPC_LOG_INTERNAL(3,_args)
+#define XPC_LOG_DEBUG(_args)    XPC_LOG_INTERNAL(4,_args)
+#define XPC_LOG_FLUSH()         PR_LogFlush()
+#define XPC_LOG_INDENT()        XPC_Log_Indent()
+#define XPC_LOG_OUTDENT()       XPC_Log_Outdent()
+#define XPC_LOG_CLEAR_INDENT()  XPC_Log_Clear_Indent()
+#define XPC_LOG_FINISH()        XPC_Log_Finish()
+
+extern "C" {
+
+void   XPC_Log_print(const char* fmt, ...);
+bool   XPC_Log_Check(int i);
+void   XPC_Log_Indent();
+void   XPC_Log_Outdent();
+void   XPC_Log_Clear_Indent();
+void   XPC_Log_Finish();
+
+} // extern "C"
+
+#else
+
+#define XPC_LOG_ALWAYS(_args)  ((void)0)
+#define XPC_LOG_ERROR(_args)   ((void)0)
+#define XPC_LOG_WARNING(_args) ((void)0)
+#define XPC_LOG_DEBUG(_args)   ((void)0)
+#define XPC_LOG_FLUSH()        ((void)0)
+#define XPC_LOG_INDENT()       ((void)0)
+#define XPC_LOG_OUTDENT()      ((void)0)
+#define XPC_LOG_CLEAR_INDENT() ((void)0)
+#define XPC_LOG_FINISH()       ((void)0)
+#endif
+
+#endif /* xpclog_h___ */
diff --git a/js/xpconnect/src/XPCMaps.cpp b/js/xpconnect/src/XPCMaps.cpp
new file mode 100644
index 000000000..0d728d7de
--- /dev/null
+++ b/js/xpconnect/src/XPCMaps.cpp
@@ -0,0 +1,405 @@
+/* -*- 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/. */
+
+/* Private maps (hashtables). */
+
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/MemoryReporting.h"
+#include "xpcprivate.h"
+
+#include "js/HashTable.h"
+
+using namespace mozilla;
+
+/***************************************************************************/
+// static shared...
+
+// Note this is returning the bit pattern of the first part of the nsID, not
+// the pointer to the nsID.
+
+static PLDHashNumber
+HashIIDPtrKey(const void* key)
+{
+    return *((js::HashNumber*)key);
+}
+
+static bool
+MatchIIDPtrKey(const PLDHashEntryHdr* entry, const void* key)
+{
+    return ((const nsID*)key)->
+                Equals(*((const nsID*)((PLDHashEntryStub*)entry)->key));
+}
+
+static PLDHashNumber
+HashNativeKey(const void* data)
+{
+    return static_cast<const XPCNativeSetKey*>(data)->Hash();
+}
+
+/***************************************************************************/
+// implement JSObject2WrappedJSMap...
+
+void
+JSObject2WrappedJSMap::UpdateWeakPointersAfterGC(XPCJSContext* context)
+{
+    // Check all wrappers and update their JSObject pointer if it has been
+    // moved. Release any wrappers whose weakly held JSObject has died.
+
+    nsTArray<RefPtr<nsXPCWrappedJS>> dying;
+    for (Map::Enum e(mTable); !e.empty(); e.popFront()) {
+        nsXPCWrappedJS* wrapper = e.front().value();
+        MOZ_ASSERT(wrapper, "found a null JS wrapper!");
+
+        // Walk the wrapper chain and update all JSObjects.
+        while (wrapper) {
+#ifdef DEBUG
+            if (!wrapper->IsSubjectToFinalization()) {
+                // If a wrapper is not subject to finalization then it roots its
+                // JS object.  If so, then it will not be about to be finalized
+                // and any necessary pointer update will have already happened
+                // when it was marked.
+                JSObject* obj = wrapper->GetJSObjectPreserveColor();
+                JSObject* prior = obj;
+                JS_UpdateWeakPointerAfterGCUnbarriered(&obj);
+                MOZ_ASSERT(obj == prior);
+            }
+#endif
+            if (wrapper->IsSubjectToFinalization()) {
+                wrapper->UpdateObjectPointerAfterGC();
+                if (!wrapper->GetJSObjectPreserveColor())
+                    dying.AppendElement(dont_AddRef(wrapper));
+            }
+            wrapper = wrapper->GetNextWrapper();
+        }
+
+        // Remove or update the JSObject key in the table if necessary.
+        JSObject* obj = e.front().key().unbarrieredGet();
+        JS_UpdateWeakPointerAfterGCUnbarriered(&obj);
+        if (!obj)
+            e.removeFront();
+        else
+            e.front().mutableKey() = obj;
+    }
+}
+
+void
+JSObject2WrappedJSMap::ShutdownMarker()
+{
+    for (Map::Range r = mTable.all(); !r.empty(); r.popFront()) {
+        nsXPCWrappedJS* wrapper = r.front().value();
+        MOZ_ASSERT(wrapper, "found a null JS wrapper!");
+        MOZ_ASSERT(wrapper->IsValid(), "found an invalid JS wrapper!");
+        wrapper->SystemIsBeingShutDown();
+    }
+}
+
+size_t
+JSObject2WrappedJSMap::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+    size_t n = mallocSizeOf(this);
+    n += mTable.sizeOfExcludingThis(mallocSizeOf);
+    return n;
+}
+
+size_t
+JSObject2WrappedJSMap::SizeOfWrappedJS(mozilla::MallocSizeOf mallocSizeOf) const
+{
+    size_t n = 0;
+    for (Map::Range r = mTable.all(); !r.empty(); r.popFront())
+        n += r.front().value()->SizeOfIncludingThis(mallocSizeOf);
+    return n;
+}
+
+/***************************************************************************/
+// implement Native2WrappedNativeMap...
+
+// static
+Native2WrappedNativeMap*
+Native2WrappedNativeMap::newMap(int length)
+{
+    return new Native2WrappedNativeMap(length);
+}
+
+Native2WrappedNativeMap::Native2WrappedNativeMap(int length)
+  : mTable(PLDHashTable::StubOps(), sizeof(Entry), length)
+{
+}
+
+size_t
+Native2WrappedNativeMap::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+    size_t n = mallocSizeOf(this);
+    n += mTable.ShallowSizeOfExcludingThis(mallocSizeOf);
+    for (auto iter = mTable.ConstIter(); !iter.Done(); iter.Next()) {
+        auto entry = static_cast<Native2WrappedNativeMap::Entry*>(iter.Get());
+        n += mallocSizeOf(entry->value);
+    }
+    return n;
+}
+
+/***************************************************************************/
+// implement IID2WrappedJSClassMap...
+
+const struct PLDHashTableOps IID2WrappedJSClassMap::Entry::sOps =
+{
+    HashIIDPtrKey,
+    MatchIIDPtrKey,
+    PLDHashTable::MoveEntryStub,
+    PLDHashTable::ClearEntryStub
+};
+
+// static
+IID2WrappedJSClassMap*
+IID2WrappedJSClassMap::newMap(int length)
+{
+    return new IID2WrappedJSClassMap(length);
+}
+
+IID2WrappedJSClassMap::IID2WrappedJSClassMap(int length)
+  : mTable(&Entry::sOps, sizeof(Entry), length)
+{
+}
+
+/***************************************************************************/
+// implement IID2NativeInterfaceMap...
+
+const struct PLDHashTableOps IID2NativeInterfaceMap::Entry::sOps =
+{
+    HashIIDPtrKey,
+    MatchIIDPtrKey,
+    PLDHashTable::MoveEntryStub,
+    PLDHashTable::ClearEntryStub
+};
+
+// static
+IID2NativeInterfaceMap*
+IID2NativeInterfaceMap::newMap(int length)
+{
+    return new IID2NativeInterfaceMap(length);
+}
+
+IID2NativeInterfaceMap::IID2NativeInterfaceMap(int length)
+  : mTable(&Entry::sOps, sizeof(Entry), length)
+{
+}
+
+size_t
+IID2NativeInterfaceMap::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+    size_t n = mallocSizeOf(this);
+    n += mTable.ShallowSizeOfExcludingThis(mallocSizeOf);
+    for (auto iter = mTable.ConstIter(); !iter.Done(); iter.Next()) {
+        auto entry = static_cast<IID2NativeInterfaceMap::Entry*>(iter.Get());
+        n += entry->value->SizeOfIncludingThis(mallocSizeOf);
+    }
+    return n;
+}
+
+/***************************************************************************/
+// implement ClassInfo2NativeSetMap...
+
+// static
+bool ClassInfo2NativeSetMap::Entry::Match(const PLDHashEntryHdr* aEntry,
+                                          const void* aKey)
+{
+    return static_cast<const Entry*>(aEntry)->key == aKey;
+}
+
+// static
+void ClassInfo2NativeSetMap::Entry::Clear(PLDHashTable* aTable,
+                                          PLDHashEntryHdr* aEntry)
+{
+    auto entry = static_cast<Entry*>(aEntry);
+    NS_RELEASE(entry->value);
+
+    entry->key = nullptr;
+    entry->value = nullptr;
+}
+
+const PLDHashTableOps ClassInfo2NativeSetMap::Entry::sOps =
+{
+    PLDHashTable::HashVoidPtrKeyStub,
+    Match,
+    PLDHashTable::MoveEntryStub,
+    Clear,
+    nullptr
+};
+
+// static
+ClassInfo2NativeSetMap*
+ClassInfo2NativeSetMap::newMap(int length)
+{
+    return new ClassInfo2NativeSetMap(length);
+}
+
+ClassInfo2NativeSetMap::ClassInfo2NativeSetMap(int length)
+  : mTable(&ClassInfo2NativeSetMap::Entry::sOps, sizeof(Entry), length)
+{
+}
+
+size_t
+ClassInfo2NativeSetMap::ShallowSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf)
+{
+    size_t n = mallocSizeOf(this);
+    n += mTable.ShallowSizeOfExcludingThis(mallocSizeOf);
+    return n;
+}
+
+/***************************************************************************/
+// implement ClassInfo2WrappedNativeProtoMap...
+
+// static
+ClassInfo2WrappedNativeProtoMap*
+ClassInfo2WrappedNativeProtoMap::newMap(int length)
+{
+    return new ClassInfo2WrappedNativeProtoMap(length);
+}
+
+ClassInfo2WrappedNativeProtoMap::ClassInfo2WrappedNativeProtoMap(int length)
+  : mTable(PLDHashTable::StubOps(), sizeof(Entry), length)
+{
+}
+
+size_t
+ClassInfo2WrappedNativeProtoMap::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+    size_t n = mallocSizeOf(this);
+    n += mTable.ShallowSizeOfExcludingThis(mallocSizeOf);
+    for (auto iter = mTable.ConstIter(); !iter.Done(); iter.Next()) {
+        auto entry = static_cast<ClassInfo2WrappedNativeProtoMap::Entry*>(iter.Get());
+        n += mallocSizeOf(entry->value);
+    }
+    return n;
+}
+
+/***************************************************************************/
+// implement NativeSetMap...
+
+bool
+NativeSetMap::Entry::Match(const PLDHashEntryHdr* entry, const void* key)
+{
+    auto Key = static_cast<const XPCNativeSetKey*>(key);
+    XPCNativeSet*       SetInTable = ((Entry*)entry)->key_value;
+    XPCNativeSet*       Set        = Key->GetBaseSet();
+    XPCNativeInterface* Addition   = Key->GetAddition();
+
+    if (!Set) {
+        // This is a special case to deal with the invariant that says:
+        // "All sets have exactly one nsISupports interface and it comes first."
+        // See XPCNativeSet::NewInstance for details.
+        //
+        // Though we might have a key that represents only one interface, we
+        // know that if that one interface were contructed into a set then
+        // it would end up really being a set with two interfaces (except for
+        // the case where the one interface happened to be nsISupports).
+
+        return (SetInTable->GetInterfaceCount() == 1 &&
+                SetInTable->GetInterfaceAt(0) == Addition) ||
+               (SetInTable->GetInterfaceCount() == 2 &&
+                SetInTable->GetInterfaceAt(1) == Addition);
+    }
+
+    if (!Addition && Set == SetInTable)
+        return true;
+
+    uint16_t count = Set->GetInterfaceCount();
+    if (count + (Addition ? 1 : 0) != SetInTable->GetInterfaceCount())
+        return false;
+
+    XPCNativeInterface** CurrentInTable = SetInTable->GetInterfaceArray();
+    XPCNativeInterface** Current = Set->GetInterfaceArray();
+    for (uint16_t i = 0; i < count; i++) {
+        if (*(Current++) != *(CurrentInTable++))
+            return false;
+    }
+    return !Addition || Addition == *(CurrentInTable++);
+}
+
+const struct PLDHashTableOps NativeSetMap::Entry::sOps =
+{
+    HashNativeKey,
+    Match,
+    PLDHashTable::MoveEntryStub,
+    PLDHashTable::ClearEntryStub
+};
+
+// static
+NativeSetMap*
+NativeSetMap::newMap(int length)
+{
+    return new NativeSetMap(length);
+}
+
+NativeSetMap::NativeSetMap(int length)
+  : mTable(&Entry::sOps, sizeof(Entry), length)
+{
+}
+
+size_t
+NativeSetMap::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+    size_t n = mallocSizeOf(this);
+    n += mTable.ShallowSizeOfExcludingThis(mallocSizeOf);
+    for (auto iter = mTable.ConstIter(); !iter.Done(); iter.Next()) {
+        auto entry = static_cast<NativeSetMap::Entry*>(iter.Get());
+        n += entry->key_value->SizeOfIncludingThis(mallocSizeOf);
+    }
+    return n;
+}
+
+/***************************************************************************/
+// implement IID2ThisTranslatorMap...
+
+bool
+IID2ThisTranslatorMap::Entry::Match(const PLDHashEntryHdr* entry,
+                                    const void* key)
+{
+    return ((const nsID*)key)->Equals(((Entry*)entry)->key);
+}
+
+void
+IID2ThisTranslatorMap::Entry::Clear(PLDHashTable* table, PLDHashEntryHdr* entry)
+{
+    static_cast<Entry*>(entry)->value = nullptr;
+    memset(entry, 0, table->EntrySize());
+}
+
+const struct PLDHashTableOps IID2ThisTranslatorMap::Entry::sOps =
+{
+    HashIIDPtrKey,
+    Match,
+    PLDHashTable::MoveEntryStub,
+    Clear
+};
+
+// static
+IID2ThisTranslatorMap*
+IID2ThisTranslatorMap::newMap(int length)
+{
+    return new IID2ThisTranslatorMap(length);
+}
+
+IID2ThisTranslatorMap::IID2ThisTranslatorMap(int length)
+  : mTable(&Entry::sOps, sizeof(Entry), length)
+{
+}
+
+/***************************************************************************/
+// implement XPCWrappedNativeProtoMap...
+
+// static
+XPCWrappedNativeProtoMap*
+XPCWrappedNativeProtoMap::newMap(int length)
+{
+    return new XPCWrappedNativeProtoMap(length);
+}
+
+XPCWrappedNativeProtoMap::XPCWrappedNativeProtoMap(int length)
+  : mTable(PLDHashTable::StubOps(), sizeof(PLDHashEntryStub), length)
+{
+}
+
+/***************************************************************************/
diff --git a/js/xpconnect/src/XPCMaps.h b/js/xpconnect/src/XPCMaps.h
new file mode 100644
index 000000000..80c51d477
--- /dev/null
+++ b/js/xpconnect/src/XPCMaps.h
@@ -0,0 +1,606 @@
+/* -*- 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/. */
+
+/* Private maps (hashtables). */
+
+#ifndef xpcmaps_h___
+#define xpcmaps_h___
+
+#include "mozilla/MemoryReporting.h"
+
+#include "js/GCHashTable.h"
+
+// Maps...
+
+// Note that most of the declarations for hash table entries begin with
+// a pointer to something or another. This makes them look enough like
+// the PLDHashEntryStub struct that the default ops (PLDHashTable::StubOps())
+// just do the right thing for most of our needs.
+
+// no virtuals in the maps - all the common stuff inlined
+// templates could be used to good effect here.
+
+/*************************/
+
+class JSObject2WrappedJSMap
+{
+    using Map = js::HashMap<JS::Heap<JSObject*>,
+                            nsXPCWrappedJS*,
+                            js::MovableCellHasher<JS::Heap<JSObject*>>,
+                            InfallibleAllocPolicy>;
+
+public:
+    static JSObject2WrappedJSMap* newMap(int length) {
+        auto* map = new JSObject2WrappedJSMap();
+        if (!map->mTable.init(length)) {
+            // This is a decent estimate of the size of the hash table's
+            // entry storage. The |2| is because on average the capacity is
+            // twice the requested length.
+            NS_ABORT_OOM(length * 2 * sizeof(Map::Entry));
+        }
+        return map;
+    }
+
+    inline nsXPCWrappedJS* Find(JSObject* Obj) {
+        NS_PRECONDITION(Obj,"bad param");
+        Map::Ptr p = mTable.lookup(Obj);
+        return p ? p->value() : nullptr;
+    }
+
+#ifdef DEBUG
+    inline bool HasWrapper(nsXPCWrappedJS* wrapper) {
+        for (auto r = mTable.all(); !r.empty(); r.popFront()) {
+            if (r.front().value() == wrapper)
+                return true;
+        }
+        return false;
+    }
+#endif
+
+    inline nsXPCWrappedJS* Add(JSContext* cx, nsXPCWrappedJS* wrapper) {
+        NS_PRECONDITION(wrapper,"bad param");
+        JSObject* obj = wrapper->GetJSObjectPreserveColor();
+        Map::AddPtr p = mTable.lookupForAdd(obj);
+        if (p)
+            return p->value();
+        if (!mTable.add(p, obj, wrapper))
+            return nullptr;
+        return wrapper;
+    }
+
+    inline void Remove(nsXPCWrappedJS* wrapper) {
+        NS_PRECONDITION(wrapper,"bad param");
+        mTable.remove(wrapper->GetJSObjectPreserveColor());
+    }
+
+    inline uint32_t Count() {return mTable.count();}
+
+    inline void Dump(int16_t depth) {
+        for (Map::Range r = mTable.all(); !r.empty(); r.popFront())
+            r.front().value()->DebugDump(depth);
+    }
+
+    void UpdateWeakPointersAfterGC(XPCJSContext* context);
+
+    void ShutdownMarker();
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+    // Report the sum of SizeOfIncludingThis() for all wrapped JS in the map.
+    // Each wrapped JS is only in one map.
+    size_t SizeOfWrappedJS(mozilla::MallocSizeOf mallocSizeOf) const;
+
+private:
+    JSObject2WrappedJSMap() {}
+
+    Map mTable;
+};
+
+/*************************/
+
+class Native2WrappedNativeMap
+{
+public:
+    struct Entry : public PLDHashEntryHdr
+    {
+        nsISupports*      key;
+        XPCWrappedNative* value;
+    };
+
+    static Native2WrappedNativeMap* newMap(int length);
+
+    inline XPCWrappedNative* Find(nsISupports* Obj)
+    {
+        NS_PRECONDITION(Obj,"bad param");
+        auto entry = static_cast<Entry*>(mTable.Search(Obj));
+        return entry ? entry->value : nullptr;
+    }
+
+    inline XPCWrappedNative* Add(XPCWrappedNative* wrapper)
+    {
+        NS_PRECONDITION(wrapper,"bad param");
+        nsISupports* obj = wrapper->GetIdentityObject();
+        MOZ_ASSERT(!Find(obj), "wrapper already in new scope!");
+        auto entry = static_cast<Entry*>(mTable.Add(obj, mozilla::fallible));
+        if (!entry)
+            return nullptr;
+        if (entry->key)
+            return entry->value;
+        entry->key = obj;
+        entry->value = wrapper;
+        return wrapper;
+    }
+
+    inline void Remove(XPCWrappedNative* wrapper)
+    {
+        NS_PRECONDITION(wrapper,"bad param");
+#ifdef DEBUG
+        XPCWrappedNative* wrapperInMap = Find(wrapper->GetIdentityObject());
+        MOZ_ASSERT(!wrapperInMap || wrapperInMap == wrapper,
+                   "About to remove a different wrapper with the same "
+                   "nsISupports identity! This will most likely cause serious "
+                   "problems!");
+#endif
+        mTable.Remove(wrapper->GetIdentityObject());
+    }
+
+    inline uint32_t Count() { return mTable.EntryCount(); }
+
+    PLDHashTable::Iterator Iter() { return mTable.Iter(); }
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+private:
+    Native2WrappedNativeMap();    // no implementation
+    explicit Native2WrappedNativeMap(int size);
+
+private:
+    PLDHashTable mTable;
+};
+
+/*************************/
+
+class IID2WrappedJSClassMap
+{
+public:
+    struct Entry : public PLDHashEntryHdr
+    {
+        const nsIID*         key;
+        nsXPCWrappedJSClass* value;
+
+        static const struct PLDHashTableOps sOps;
+    };
+
+    static IID2WrappedJSClassMap* newMap(int length);
+
+    inline nsXPCWrappedJSClass* Find(REFNSIID iid)
+    {
+        auto entry = static_cast<Entry*>(mTable.Search(&iid));
+        return entry ? entry->value : nullptr;
+    }
+
+    inline nsXPCWrappedJSClass* Add(nsXPCWrappedJSClass* clazz)
+    {
+        NS_PRECONDITION(clazz,"bad param");
+        const nsIID* iid = &clazz->GetIID();
+        auto entry = static_cast<Entry*>(mTable.Add(iid, mozilla::fallible));
+        if (!entry)
+            return nullptr;
+        if (entry->key)
+            return entry->value;
+        entry->key = iid;
+        entry->value = clazz;
+        return clazz;
+    }
+
+    inline void Remove(nsXPCWrappedJSClass* clazz)
+    {
+        NS_PRECONDITION(clazz,"bad param");
+        mTable.Remove(&clazz->GetIID());
+    }
+
+    inline uint32_t Count() { return mTable.EntryCount(); }
+
+#ifdef DEBUG
+    PLDHashTable::Iterator Iter() { return mTable.Iter(); }
+#endif
+
+private:
+    IID2WrappedJSClassMap();    // no implementation
+    explicit IID2WrappedJSClassMap(int size);
+private:
+    PLDHashTable mTable;
+};
+
+/*************************/
+
+class IID2NativeInterfaceMap
+{
+public:
+    struct Entry : public PLDHashEntryHdr
+    {
+        const nsIID*        key;
+        XPCNativeInterface* value;
+
+        static const struct PLDHashTableOps sOps;
+    };
+
+    static IID2NativeInterfaceMap* newMap(int length);
+
+    inline XPCNativeInterface* Find(REFNSIID iid)
+    {
+        auto entry = static_cast<Entry*>(mTable.Search(&iid));
+        return entry ? entry->value : nullptr;
+    }
+
+    inline XPCNativeInterface* Add(XPCNativeInterface* iface)
+    {
+        NS_PRECONDITION(iface,"bad param");
+        const nsIID* iid = iface->GetIID();
+        auto entry = static_cast<Entry*>(mTable.Add(iid, mozilla::fallible));
+        if (!entry)
+            return nullptr;
+        if (entry->key)
+            return entry->value;
+        entry->key = iid;
+        entry->value = iface;
+        return iface;
+    }
+
+    inline void Remove(XPCNativeInterface* iface)
+    {
+        NS_PRECONDITION(iface,"bad param");
+        mTable.Remove(iface->GetIID());
+    }
+
+    inline uint32_t Count() { return mTable.EntryCount(); }
+
+    PLDHashTable::Iterator Iter() { return mTable.Iter(); }
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+private:
+    IID2NativeInterfaceMap();    // no implementation
+    explicit IID2NativeInterfaceMap(int size);
+
+private:
+    PLDHashTable mTable;
+};
+
+/*************************/
+
+class ClassInfo2NativeSetMap
+{
+public:
+    struct Entry : public PLDHashEntryHdr
+    {
+        nsIClassInfo* key;
+        XPCNativeSet* value; // strong reference
+        static const PLDHashTableOps sOps;
+
+    private:
+        static bool Match(const PLDHashEntryHdr* aEntry, const void* aKey);
+        static void Clear(PLDHashTable* aTable, PLDHashEntryHdr* aEntry);
+    };
+
+    static ClassInfo2NativeSetMap* newMap(int length);
+
+    inline XPCNativeSet* Find(nsIClassInfo* info)
+    {
+        auto entry = static_cast<Entry*>(mTable.Search(info));
+        return entry ? entry->value : nullptr;
+    }
+
+    inline XPCNativeSet* Add(nsIClassInfo* info, XPCNativeSet* set)
+    {
+        NS_PRECONDITION(info,"bad param");
+        auto entry = static_cast<Entry*>(mTable.Add(info, mozilla::fallible));
+        if (!entry)
+            return nullptr;
+        if (entry->key)
+            return entry->value;
+        entry->key = info;
+        NS_ADDREF(entry->value = set);
+        return set;
+    }
+
+    inline void Remove(nsIClassInfo* info)
+    {
+        NS_PRECONDITION(info,"bad param");
+        mTable.Remove(info);
+    }
+
+    inline uint32_t Count() { return mTable.EntryCount(); }
+
+    // ClassInfo2NativeSetMap holds pointers to *some* XPCNativeSets.
+    // So we don't want to count those XPCNativeSets, because they are better
+    // counted elsewhere (i.e. in XPCJSContext::mNativeSetMap, which holds
+    // pointers to *all* XPCNativeSets).  Hence the "Shallow".
+    size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);
+
+private:
+    ClassInfo2NativeSetMap();    // no implementation
+    explicit ClassInfo2NativeSetMap(int size);
+private:
+    PLDHashTable mTable;
+};
+
+/*************************/
+
+class ClassInfo2WrappedNativeProtoMap
+{
+public:
+    struct Entry : public PLDHashEntryHdr
+    {
+        nsIClassInfo*          key;
+        XPCWrappedNativeProto* value;
+    };
+
+    static ClassInfo2WrappedNativeProtoMap* newMap(int length);
+
+    inline XPCWrappedNativeProto* Find(nsIClassInfo* info)
+    {
+        auto entry = static_cast<Entry*>(mTable.Search(info));
+        return entry ? entry->value : nullptr;
+    }
+
+    inline XPCWrappedNativeProto* Add(nsIClassInfo* info, XPCWrappedNativeProto* proto)
+    {
+        NS_PRECONDITION(info,"bad param");
+        auto entry = static_cast<Entry*>(mTable.Add(info, mozilla::fallible));
+        if (!entry)
+            return nullptr;
+        if (entry->key)
+            return entry->value;
+        entry->key = info;
+        entry->value = proto;
+        return proto;
+    }
+
+    inline void Remove(nsIClassInfo* info)
+    {
+        NS_PRECONDITION(info,"bad param");
+        mTable.Remove(info);
+    }
+
+    inline uint32_t Count() { return mTable.EntryCount(); }
+
+    PLDHashTable::Iterator Iter() { return mTable.Iter(); }
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+private:
+    ClassInfo2WrappedNativeProtoMap();    // no implementation
+    explicit ClassInfo2WrappedNativeProtoMap(int size);
+
+private:
+    PLDHashTable mTable;
+};
+
+/*************************/
+
+class NativeSetMap
+{
+public:
+    struct Entry : public PLDHashEntryHdr
+    {
+        XPCNativeSet* key_value;
+
+        static bool
+        Match(const PLDHashEntryHdr* entry, const void* key);
+
+        static const struct PLDHashTableOps sOps;
+    };
+
+    static NativeSetMap* newMap(int length);
+
+    inline XPCNativeSet* Find(XPCNativeSetKey* key)
+    {
+        auto entry = static_cast<Entry*>(mTable.Search(key));
+        return entry ? entry->key_value : nullptr;
+    }
+
+    inline XPCNativeSet* Add(const XPCNativeSetKey* key, XPCNativeSet* set)
+    {
+        MOZ_ASSERT(key, "bad param");
+        MOZ_ASSERT(set, "bad param");
+        auto entry = static_cast<Entry*>(mTable.Add(key, mozilla::fallible));
+        if (!entry)
+            return nullptr;
+        if (entry->key_value)
+            return entry->key_value;
+        entry->key_value = set;
+        return set;
+    }
+
+    bool AddNew(const XPCNativeSetKey* key, XPCNativeSet* set)
+    {
+        XPCNativeSet* set2 = Add(key, set);
+        if (!set2) {
+            return false;
+        }
+#ifdef DEBUG
+        XPCNativeSetKey key2(set);
+        MOZ_ASSERT(key->Hash() == key2.Hash());
+        MOZ_ASSERT(set2 == set, "Should not have found an existing entry");
+#endif
+        return true;
+    }
+
+    inline void Remove(XPCNativeSet* set)
+    {
+        MOZ_ASSERT(set, "bad param");
+
+        XPCNativeSetKey key(set);
+        mTable.Remove(&key);
+    }
+
+    inline uint32_t Count() { return mTable.EntryCount(); }
+
+    PLDHashTable::Iterator Iter() { return mTable.Iter(); }
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+private:
+    NativeSetMap();    // no implementation
+    explicit NativeSetMap(int size);
+
+private:
+    PLDHashTable mTable;
+};
+
+/***************************************************************************/
+
+class IID2ThisTranslatorMap
+{
+public:
+    struct Entry : public PLDHashEntryHdr
+    {
+        nsIID                                  key;
+        nsCOMPtr<nsIXPCFunctionThisTranslator> value;
+
+        static bool
+        Match(const PLDHashEntryHdr* entry, const void* key);
+
+        static void
+        Clear(PLDHashTable* table, PLDHashEntryHdr* entry);
+
+        static const struct PLDHashTableOps sOps;
+    };
+
+    static IID2ThisTranslatorMap* newMap(int length);
+
+    inline nsIXPCFunctionThisTranslator* Find(REFNSIID iid)
+    {
+        auto entry = static_cast<Entry*>(mTable.Search(&iid));
+        if (!entry) {
+            return nullptr;
+        }
+        return entry->value;
+    }
+
+    inline nsIXPCFunctionThisTranslator* Add(REFNSIID iid,
+                                             nsIXPCFunctionThisTranslator* obj)
+    {
+        auto entry = static_cast<Entry*>(mTable.Add(&iid, mozilla::fallible));
+        if (!entry)
+            return nullptr;
+        entry->value = obj;
+        entry->key = iid;
+        return obj;
+    }
+
+    inline void Remove(REFNSIID iid)
+    {
+        mTable.Remove(&iid);
+    }
+
+    inline uint32_t Count() { return mTable.EntryCount(); }
+
+private:
+    IID2ThisTranslatorMap();    // no implementation
+    explicit IID2ThisTranslatorMap(int size);
+private:
+    PLDHashTable mTable;
+};
+
+/***************************************************************************/
+
+class XPCWrappedNativeProtoMap
+{
+public:
+    typedef PLDHashEntryStub Entry;
+
+    static XPCWrappedNativeProtoMap* newMap(int length);
+
+    inline XPCWrappedNativeProto* Add(XPCWrappedNativeProto* proto)
+    {
+        NS_PRECONDITION(proto,"bad param");
+        auto entry = static_cast<PLDHashEntryStub*>
+                                (mTable.Add(proto, mozilla::fallible));
+        if (!entry)
+            return nullptr;
+        if (entry->key)
+            return (XPCWrappedNativeProto*) entry->key;
+        entry->key = proto;
+        return proto;
+    }
+
+    inline void Remove(XPCWrappedNativeProto* proto)
+    {
+        NS_PRECONDITION(proto,"bad param");
+        mTable.Remove(proto);
+    }
+
+    inline uint32_t Count() { return mTable.EntryCount(); }
+
+    PLDHashTable::Iterator Iter() { return mTable.Iter(); }
+
+private:
+    XPCWrappedNativeProtoMap();    // no implementation
+    explicit XPCWrappedNativeProtoMap(int size);
+private:
+    PLDHashTable mTable;
+};
+
+/***************************************************************************/
+
+class JSObject2JSObjectMap
+{
+    using Map = JS::GCHashMap<JS::Heap<JSObject*>,
+                              JS::Heap<JSObject*>,
+                              js::MovableCellHasher<JS::Heap<JSObject*>>,
+                              js::SystemAllocPolicy>;
+
+public:
+    static JSObject2JSObjectMap* newMap(int length) {
+        auto* map = new JSObject2JSObjectMap();
+        if (!map->mTable.init(length)) {
+            // This is a decent estimate of the size of the hash table's
+            // entry storage. The |2| is because on average the capacity is
+            // twice the requested length.
+            NS_ABORT_OOM(length * 2 * sizeof(Map::Entry));
+        }
+        return map;
+    }
+
+    inline JSObject* Find(JSObject* key) {
+        NS_PRECONDITION(key, "bad param");
+        if (Map::Ptr p = mTable.lookup(key))
+            return p->value();
+        return nullptr;
+    }
+
+    /* Note: If the entry already exists, return the old value. */
+    inline JSObject* Add(JSContext* cx, JSObject* key, JSObject* value) {
+        NS_PRECONDITION(key,"bad param");
+        Map::AddPtr p = mTable.lookupForAdd(key);
+        if (p)
+            return p->value();
+        if (!mTable.add(p, key, value))
+            return nullptr;
+        MOZ_ASSERT(xpc::CompartmentPrivate::Get(key)->scope->mWaiverWrapperMap == this);
+        return value;
+    }
+
+    inline void Remove(JSObject* key) {
+        NS_PRECONDITION(key,"bad param");
+        mTable.remove(key);
+    }
+
+    inline uint32_t Count() { return mTable.count(); }
+
+    void Sweep() {
+        mTable.sweep();
+    }
+
+private:
+    JSObject2JSObjectMap() {}
+
+    Map mTable;
+};
+
+#endif /* xpcmaps_h___ */
diff --git a/js/xpconnect/src/XPCModule.cpp b/js/xpconnect/src/XPCModule.cpp
new file mode 100644
index 000000000..52100b39a
--- /dev/null
+++ b/js/xpconnect/src/XPCModule.cpp
@@ -0,0 +1,24 @@
+/* -*- 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/. */
+
+#define XPCONNECT_MODULE
+#include "xpcprivate.h"
+
+nsresult
+xpcModuleCtor()
+{
+    nsXPConnect::InitStatics();
+
+    return NS_OK;
+}
+
+void
+xpcModuleDtor()
+{
+    // Release our singletons
+    nsXPConnect::ReleaseXPConnectSingleton();
+    xpc_DestroyJSxIDClassObjects();
+}
diff --git a/js/xpconnect/src/XPCModule.h b/js/xpconnect/src/XPCModule.h
new file mode 100644
index 000000000..d62764625
--- /dev/null
+++ b/js/xpconnect/src/XPCModule.h
@@ -0,0 +1,57 @@
+/* -*- 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 "xpcprivate.h"
+#include "mozilla/ModuleUtils.h"
+#include "mozJSComponentLoader.h"
+#include "mozJSSubScriptLoader.h"
+
+/* Module implementation for the xpconnect library. */
+
+#define XPCVARIANT_CONTRACTID "@mozilla.org/xpcvariant;1"
+
+// {FE4F7592-C1FC-4662-AC83-538841318803}
+#define SCRIPTABLE_INTERFACES_CID                                             \
+    {0xfe4f7592, 0xc1fc, 0x4662,                                              \
+      { 0xac, 0x83, 0x53, 0x88, 0x41, 0x31, 0x88, 0x3 } }
+
+#define MOZJSSUBSCRIPTLOADER_CONTRACTID "@mozilla.org/moz/jssubscript-loader;1"
+
+NS_GENERIC_FACTORY_CONSTRUCTOR(nsJSID)
+NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIXPConnect,
+                                         nsXPConnect::GetSingleton)
+NS_GENERIC_FACTORY_CONSTRUCTOR(nsScriptError)
+
+NS_GENERIC_FACTORY_CONSTRUCTOR(mozJSComponentLoader)
+NS_GENERIC_FACTORY_CONSTRUCTOR(mozJSSubScriptLoader)
+
+NS_DEFINE_NAMED_CID(NS_JS_ID_CID);
+NS_DEFINE_NAMED_CID(NS_XPCONNECT_CID);
+NS_DEFINE_NAMED_CID(NS_XPCEXCEPTION_CID);
+NS_DEFINE_NAMED_CID(NS_SCRIPTERROR_CID);
+NS_DEFINE_NAMED_CID(MOZJSCOMPONENTLOADER_CID);
+NS_DEFINE_NAMED_CID(MOZ_JSSUBSCRIPTLOADER_CID);
+
+#define XPCONNECT_CIDENTRIES                                                  \
+  { &kNS_JS_ID_CID, false, nullptr,  nsJSIDConstructor },                     \
+  { &kNS_XPCONNECT_CID, false, nullptr,  nsIXPConnectConstructor },           \
+  { &kNS_SCRIPTERROR_CID, false, nullptr, nsScriptErrorConstructor },         \
+  { &kMOZJSCOMPONENTLOADER_CID, false, nullptr, mozJSComponentLoaderConstructor },\
+  { &kMOZ_JSSUBSCRIPTLOADER_CID, false, nullptr, mozJSSubScriptLoaderConstructor },
+
+#define XPCONNECT_CONTRACTS                                                   \
+  { XPC_ID_CONTRACTID, &kNS_JS_ID_CID },                                      \
+  { XPC_XPCONNECT_CONTRACTID, &kNS_XPCONNECT_CID },                           \
+  { XPC_CONTEXT_STACK_CONTRACTID, &kNS_XPCONNECT_CID },                       \
+  { NS_SCRIPTERROR_CONTRACTID, &kNS_SCRIPTERROR_CID },                        \
+  { MOZJSCOMPONENTLOADER_CONTRACTID, &kMOZJSCOMPONENTLOADER_CID },            \
+  { MOZJSSUBSCRIPTLOADER_CONTRACTID, &kMOZ_JSSUBSCRIPTLOADER_CID },
+
+#define XPCONNECT_CATEGORIES \
+  { "module-loader", "js", MOZJSCOMPONENTLOADER_CONTRACTID },
+
+nsresult xpcModuleCtor();
+void xpcModuleDtor();
diff --git a/js/xpconnect/src/XPCRuntimeService.cpp b/js/xpconnect/src/XPCRuntimeService.cpp
new file mode 100644
index 000000000..ce79dcc86
--- /dev/null
+++ b/js/xpconnect/src/XPCRuntimeService.cpp
@@ -0,0 +1,189 @@
+/* -*- 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 "xpcprivate.h"
+
+#include "nsContentUtils.h"
+#include "BackstagePass.h"
+#include "nsDOMClassInfo.h"
+#include "nsIPrincipal.h"
+#include "mozilla/dom/BindingUtils.h"
+
+NS_INTERFACE_MAP_BEGIN(BackstagePass)
+  NS_INTERFACE_MAP_ENTRY(nsIGlobalObject)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
+  NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
+  NS_INTERFACE_MAP_ENTRY(nsIScriptObjectPrincipal)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPCScriptable)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF(BackstagePass)
+NS_IMPL_RELEASE(BackstagePass)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           BackstagePass
+#define XPC_MAP_QUOTED_CLASSNAME   "BackstagePass"
+#define                             XPC_MAP_WANT_RESOLVE
+#define                             XPC_MAP_WANT_ENUMERATE
+#define                             XPC_MAP_WANT_FINALIZE
+#define                             XPC_MAP_WANT_PRECREATE
+
+#define XPC_MAP_FLAGS       nsIXPCScriptable::USE_JSSTUB_FOR_ADDPROPERTY   |  \
+                            nsIXPCScriptable::USE_JSSTUB_FOR_DELPROPERTY   |  \
+                            nsIXPCScriptable::USE_JSSTUB_FOR_SETPROPERTY   |  \
+                            nsIXPCScriptable::DONT_ENUM_QUERY_INTERFACE    |  \
+                            nsIXPCScriptable::IS_GLOBAL_OBJECT             |  \
+                            nsIXPCScriptable::DONT_REFLECT_INTERFACE_NAMES
+#include "xpc_map_end.h" /* This will #undef the above */
+
+
+JSObject*
+BackstagePass::GetGlobalJSObject()
+{
+    if (mWrapper)
+        return mWrapper->GetFlatJSObject();
+    return nullptr;
+}
+
+void
+BackstagePass::SetGlobalObject(JSObject* global)
+{
+    nsISupports* p = XPCWrappedNative::Get(global);
+    MOZ_ASSERT(p);
+    mWrapper = static_cast<XPCWrappedNative*>(p);
+}
+
+NS_IMETHODIMP
+BackstagePass::Resolve(nsIXPConnectWrappedNative* wrapper,
+                       JSContext * cx, JSObject * objArg,
+                       jsid idArg, bool* resolvedp,
+                       bool* _retval)
+{
+    JS::RootedObject obj(cx, objArg);
+    JS::RootedId id(cx, idArg);
+    *_retval = mozilla::dom::SystemGlobalResolve(cx, obj, id, resolvedp);
+    return *_retval ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+BackstagePass::Enumerate(nsIXPConnectWrappedNative* wrapper, JSContext* cx,
+                         JSObject* objArg, bool* _retval)
+{
+    JS::RootedObject obj(cx, objArg);
+    *_retval = mozilla::dom::SystemGlobalEnumerate(cx, obj);
+    return *_retval ? NS_OK : NS_ERROR_FAILURE;
+}
+
+/***************************************************************************/
+NS_IMETHODIMP
+BackstagePass::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
+{
+    const uint32_t count = 2;
+    *aCount = count;
+    nsIID** array;
+    *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
+    if (!array)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    uint32_t index = 0;
+    nsIID* clone;
+#define PUSH_IID(id)                                                          \
+    clone = static_cast<nsIID*>(nsMemory::Clone(&NS_GET_IID( id ),           \
+                                                 sizeof(nsIID)));             \
+    if (!clone)                                                               \
+        goto oom;                                                             \
+    array[index++] = clone;
+
+    PUSH_IID(nsIXPCScriptable)
+    PUSH_IID(nsIScriptObjectPrincipal)
+#undef PUSH_IID
+
+    return NS_OK;
+oom:
+    while (index)
+        free(array[--index]);
+    free(array);
+    *aArray = nullptr;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+BackstagePass::GetScriptableHelper(nsIXPCScriptable** retval)
+{
+    nsCOMPtr<nsIXPCScriptable> scriptable = this;
+    scriptable.forget(retval);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+BackstagePass::GetContractID(char * *aContractID)
+{
+    *aContractID = nullptr;
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+BackstagePass::GetClassDescription(char * *aClassDescription)
+{
+    static const char classDescription[] = "BackstagePass";
+    *aClassDescription = (char*)nsMemory::Clone(classDescription, sizeof(classDescription));
+    return *aClassDescription ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+BackstagePass::GetClassID(nsCID * *aClassID)
+{
+    *aClassID = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+BackstagePass::GetFlags(uint32_t* aFlags)
+{
+    *aFlags = nsIClassInfo::MAIN_THREAD_ONLY;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+BackstagePass::GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+BackstagePass::Finalize(nsIXPConnectWrappedNative* wrapper, JSFreeOp * fop, JSObject * obj)
+{
+    nsCOMPtr<nsIGlobalObject> bsp(do_QueryWrappedNative(wrapper));
+    MOZ_ASSERT(bsp);
+    static_cast<BackstagePass*>(bsp.get())->ForgetGlobalObject();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+BackstagePass::PreCreate(nsISupports* nativeObj, JSContext* cx,
+                         JSObject* globalObj, JSObject** parentObj)
+{
+    // We do the same trick here as for WindowSH. Return the js global
+    // as parent, so XPConenct can find the right scope and the wrapper
+    // that already exists.
+    nsCOMPtr<nsIGlobalObject> global(do_QueryInterface(nativeObj));
+    MOZ_ASSERT(global, "nativeObj not a global object!");
+
+    JSObject* jsglobal = global->GetGlobalJSObject();
+    if (jsglobal)
+        *parentObj = jsglobal;
+    return NS_OK;
+}
+
+nsresult
+NS_NewBackstagePass(BackstagePass** ret)
+{
+    RefPtr<BackstagePass> bsp = new BackstagePass(
+        nsContentUtils::GetSystemPrincipal());
+    bsp.forget(ret);
+    return NS_OK;
+}
diff --git a/js/xpconnect/src/XPCShellImpl.cpp b/js/xpconnect/src/XPCShellImpl.cpp
new file mode 100644
index 000000000..d86b5c5d3
--- /dev/null
+++ b/js/xpconnect/src/XPCShellImpl.cpp
@@ -0,0 +1,1765 @@
+/* -*- 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 "nsXULAppAPI.h"
+#include "jsapi.h"
+#include "jsfriendapi.h"
+#include "jsprf.h"
+#include "mozilla/ChaosMode.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/Preferences.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIXPConnect.h"
+#include "nsIServiceManager.h"
+#include "nsIFile.h"
+#include "nsString.h"
+#include "nsIDirectoryService.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nscore.h"
+#include "nsArrayEnumerator.h"
+#include "nsCOMArray.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsCOMPtr.h"
+#include "nsJSPrincipals.h"
+#include "xpcpublic.h"
+#include "xpcprivate.h"
+#include "BackstagePass.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsIPrincipal.h"
+#include "nsJSUtils.h"
+#include "gfxPrefs.h"
+#include "nsIXULRuntime.h"
+
+#include "base/histogram.h"
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+
+#ifdef XP_WIN
+#include "mozilla/widget/AudioSession.h"
+#include <windows.h>
+#if defined(MOZ_SANDBOX)
+#include "SandboxBroker.h"
+#endif
+#endif
+
+// all this crap is needed to do the interactive shell stuff
+#include <stdlib.h>
+#include <errno.h>
+#ifdef HAVE_IO_H
+#include <io.h>     /* for isatty() */
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>     /* for isatty() */
+#endif
+
+#ifdef MOZ_CRASHREPORTER
+#include "nsExceptionHandler.h"
+#include "nsICrashReporter.h"
+#endif
+
+using namespace mozilla;
+using namespace JS;
+using mozilla::dom::AutoJSAPI;
+using mozilla::dom::AutoEntryScript;
+
+class XPCShellDirProvider : public nsIDirectoryServiceProvider2
+{
+public:
+    NS_DECL_ISUPPORTS_INHERITED
+    NS_DECL_NSIDIRECTORYSERVICEPROVIDER
+    NS_DECL_NSIDIRECTORYSERVICEPROVIDER2
+
+    XPCShellDirProvider() { }
+    ~XPCShellDirProvider() { }
+
+    // The platform resource folder
+    void SetGREDirs(nsIFile* greDir);
+    void ClearGREDirs() { mGREDir = nullptr;
+                          mGREBinDir = nullptr; }
+    // The application resource folder
+    void SetAppDir(nsIFile* appFile);
+    void ClearAppDir() { mAppDir = nullptr; }
+    // The app executable
+    void SetAppFile(nsIFile* appFile);
+    void ClearAppFile() { mAppFile = nullptr; }
+    // An additional custom plugin dir if specified
+    void SetPluginDir(nsIFile* pluginDir);
+    void ClearPluginDir() { mPluginDir = nullptr; }
+
+private:
+    nsCOMPtr<nsIFile> mGREDir;
+    nsCOMPtr<nsIFile> mGREBinDir;
+    nsCOMPtr<nsIFile> mAppDir;
+    nsCOMPtr<nsIFile> mPluginDir;
+    nsCOMPtr<nsIFile> mAppFile;
+};
+
+#ifdef XP_WIN
+class MOZ_STACK_CLASS AutoAudioSession
+{
+public:
+    AutoAudioSession() {
+        widget::StartAudioSession();
+    }
+
+    ~AutoAudioSession() {
+        widget::StopAudioSession();
+    }
+};
+#endif
+
+static const char kXPConnectServiceContractID[] = "@mozilla.org/js/xpc/XPConnect;1";
+
+#define EXITCODE_RUNTIME_ERROR 3
+#define EXITCODE_FILE_NOT_FOUND 4
+
+static FILE* gOutFile = nullptr;
+static FILE* gErrFile = nullptr;
+static FILE* gInFile = nullptr;
+
+static int gExitCode = 0;
+static bool gQuitting = false;
+static bool reportWarnings = true;
+static bool compileOnly = false;
+
+static JSPrincipals* gJSPrincipals = nullptr;
+static nsAutoString* gWorkingDirectory = nullptr;
+
+static bool
+GetLocationProperty(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (!args.thisv().isObject()) {
+        JS_ReportErrorASCII(cx, "Unexpected this value for GetLocationProperty");
+        return false;
+    }
+#if !defined(XP_WIN) && !defined(XP_UNIX)
+    //XXX: your platform should really implement this
+    return false;
+#else
+    JS::AutoFilename filename;
+    if (JS::DescribeScriptedCaller(cx, &filename) && filename.get()) {
+        nsresult rv;
+        nsCOMPtr<nsIXPConnect> xpc =
+            do_GetService(kXPConnectServiceContractID, &rv);
+
+#if defined(XP_WIN)
+        // convert from the system codepage to UTF-16
+        int bufferSize = MultiByteToWideChar(CP_ACP, 0, filename.get(),
+                                             -1, nullptr, 0);
+        nsAutoString filenameString;
+        filenameString.SetLength(bufferSize);
+        MultiByteToWideChar(CP_ACP, 0, filename.get(),
+                            -1, (LPWSTR)filenameString.BeginWriting(),
+                            filenameString.Length());
+        // remove the null terminator
+        filenameString.SetLength(bufferSize - 1);
+
+        // replace forward slashes with backslashes,
+        // since nsLocalFileWin chokes on them
+        char16_t* start = filenameString.BeginWriting();
+        char16_t* end = filenameString.EndWriting();
+
+        while (start != end) {
+            if (*start == L'/')
+                *start = L'\\';
+            start++;
+        }
+#elif defined(XP_UNIX)
+        NS_ConvertUTF8toUTF16 filenameString(filename.get());
+#endif
+
+        nsCOMPtr<nsIFile> location;
+        if (NS_SUCCEEDED(rv)) {
+            rv = NS_NewLocalFile(filenameString,
+                                 false, getter_AddRefs(location));
+        }
+
+        if (!location && gWorkingDirectory) {
+            // could be a relative path, try appending it to the cwd
+            // and then normalize
+            nsAutoString absolutePath(*gWorkingDirectory);
+            absolutePath.Append(filenameString);
+
+            rv = NS_NewLocalFile(absolutePath,
+                                 false, getter_AddRefs(location));
+        }
+
+        if (location) {
+            bool symlink;
+            // don't normalize symlinks, because that's kind of confusing
+            if (NS_SUCCEEDED(location->IsSymlink(&symlink)) &&
+                !symlink)
+                location->Normalize();
+            RootedObject locationObj(cx);
+            rv = xpc->WrapNative(cx, &args.thisv().toObject(), location,
+                                 NS_GET_IID(nsIFile), locationObj.address());
+            if (NS_SUCCEEDED(rv) && locationObj) {
+                args.rval().setObject(*locationObj);
+            }
+        }
+    }
+
+    return true;
+#endif
+}
+
+static bool
+GetLine(JSContext* cx, char* bufp, FILE* file, const char* prompt)
+{
+    fputs(prompt, gOutFile);
+    fflush(gOutFile);
+
+    char line[4096] = { '\0' };
+    while (true) {
+        if (fgets(line, sizeof line, file)) {
+            strcpy(bufp, line);
+            return true;
+        }
+        if (errno != EINTR) {
+            return false;
+        }
+    }
+}
+
+static bool
+ReadLine(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    // While 4096 might be quite arbitrary, this is something to be fixed in
+    // bug 105707. It is also the same limit as in ProcessFile.
+    char buf[4096];
+    RootedString str(cx);
+
+    /* If a prompt was specified, construct the string */
+    if (args.length() > 0) {
+        str = JS::ToString(cx, args[0]);
+        if (!str)
+            return false;
+    } else {
+        str = JS_GetEmptyString(cx);
+    }
+
+    /* Get a line from the infile */
+    JSAutoByteString strBytes(cx, str);
+    if (!strBytes || !GetLine(cx, buf, gInFile, strBytes.ptr()))
+        return false;
+
+    /* Strip newline character added by GetLine() */
+    unsigned int buflen = strlen(buf);
+    if (buflen == 0) {
+        if (feof(gInFile)) {
+            args.rval().setNull();
+            return true;
+        }
+    } else if (buf[buflen - 1] == '\n') {
+        --buflen;
+    }
+
+    /* Turn buf into a JSString */
+    str = JS_NewStringCopyN(cx, buf, buflen);
+    if (!str)
+        return false;
+
+    args.rval().setString(str);
+    return true;
+}
+
+static bool
+Print(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    args.rval().setUndefined();
+
+    RootedString str(cx);
+    nsAutoCString utf8output;
+
+    for (unsigned i = 0; i < args.length(); i++) {
+        str = ToString(cx, args[i]);
+        if (!str)
+            return false;
+
+        JSAutoByteString utf8str;
+        if (!utf8str.encodeUtf8(cx, str))
+            return false;
+
+        if (i)
+            utf8output.Append(' ');
+        utf8output.Append(utf8str.ptr(), utf8str.length());
+    }
+    utf8output.Append('\n');
+    fputs(utf8output.get(), gOutFile);
+    fflush(gOutFile);
+    return true;
+}
+
+static bool
+Dump(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    args.rval().setUndefined();
+
+    if (!args.length())
+         return true;
+
+    RootedString str(cx, ToString(cx, args[0]));
+    if (!str)
+        return false;
+
+    JSAutoByteString utf8str;
+    if (!utf8str.encodeUtf8(cx, str))
+        return false;
+
+#ifdef ANDROID
+    __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", utf8str.ptr());
+#endif
+#ifdef XP_WIN
+    if (IsDebuggerPresent()) {
+        nsAutoJSString wstr;
+        if (!wstr.init(cx, str))
+            return false;
+        OutputDebugStringW(wstr.get());
+    }
+#endif
+    fputs(utf8str.ptr(), gOutFile);
+    fflush(gOutFile);
+    return true;
+}
+
+static bool
+Load(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    JS::Rooted<JSObject*> obj(cx, JS_THIS_OBJECT(cx, vp));
+    if (!obj)
+        return false;
+
+    if (!JS_IsGlobalObject(obj)) {
+        JS_ReportErrorASCII(cx, "Trying to load() into a non-global object");
+        return false;
+    }
+
+    RootedString str(cx);
+    for (unsigned i = 0; i < args.length(); i++) {
+        str = ToString(cx, args[i]);
+        if (!str)
+            return false;
+        JSAutoByteString filename(cx, str);
+        if (!filename)
+            return false;
+        FILE* file = fopen(filename.ptr(), "r");
+        if (!file) {
+            filename.clear();
+            if (!filename.encodeUtf8(cx, str))
+                return false;
+            JS_ReportErrorUTF8(cx, "cannot open file '%s' for reading",
+                               filename.ptr());
+            return false;
+        }
+        JS::CompileOptions options(cx);
+        options.setUTF8(true)
+               .setFileAndLine(filename.ptr(), 1)
+               .setIsRunOnce(true);
+        JS::Rooted<JSScript*> script(cx);
+        JS::Rooted<JSObject*> global(cx, JS::CurrentGlobalOrNull(cx));
+        JS::Compile(cx, options, file, &script);
+        fclose(file);
+        if (!script)
+            return false;
+
+        if (!compileOnly) {
+            if (!JS_ExecuteScript(cx, script)) {
+                return false;
+            }
+        }
+    }
+    args.rval().setUndefined();
+    return true;
+}
+
+static bool
+Version(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    args.rval().setInt32(JS_GetVersion(cx));
+    if (args.get(0).isInt32())
+        JS_SetVersionForCompartment(js::GetContextCompartment(cx),
+                                    JSVersion(args[0].toInt32()));
+    return true;
+}
+
+static bool
+Quit(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    gExitCode = 0;
+    if (!ToInt32(cx, args.get(0), &gExitCode))
+        return false;
+
+    gQuitting = true;
+//    exit(0);
+    return false;
+}
+
+static bool
+DumpXPC(JSContext* cx, unsigned argc, Value* vp)
+{
+    JS::CallArgs args = CallArgsFromVp(argc, vp);
+
+    uint16_t depth = 2;
+    if (args.length() > 0) {
+        if (!JS::ToUint16(cx, args[0], &depth))
+            return false;
+    }
+
+    nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID());
+    if (xpc)
+        xpc->DebugDump(int16_t(depth));
+    args.rval().setUndefined();
+    return true;
+}
+
+static bool
+GC(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    JS_GC(cx);
+
+    args.rval().setUndefined();
+    return true;
+}
+
+#ifdef JS_GC_ZEAL
+static bool
+GCZeal(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    uint32_t zeal;
+    if (!ToUint32(cx, args.get(0), &zeal))
+        return false;
+
+    JS_SetGCZeal(cx, uint8_t(zeal), JS_DEFAULT_ZEAL_FREQ);
+    args.rval().setUndefined();
+    return true;
+}
+#endif
+
+static bool
+SendCommand(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    if (args.length() == 0) {
+        JS_ReportErrorASCII(cx, "Function takes at least one argument!");
+        return false;
+    }
+
+    RootedString str(cx, ToString(cx, args[0]));
+    if (!str) {
+        JS_ReportErrorASCII(cx, "Could not convert argument 1 to string!");
+        return false;
+    }
+
+    if (args.length() > 1 && JS_TypeOfValue(cx, args[1]) != JSTYPE_FUNCTION) {
+        JS_ReportErrorASCII(cx, "Could not convert argument 2 to function!");
+        return false;
+    }
+
+    if (!XRE_SendTestShellCommand(cx, str, args.length() > 1 ? args[1].address() : nullptr)) {
+        JS_ReportErrorASCII(cx, "Couldn't send command!");
+        return false;
+    }
+
+    args.rval().setUndefined();
+    return true;
+}
+
+static bool
+Options(JSContext* cx, unsigned argc, Value* vp)
+{
+    JS::CallArgs args = CallArgsFromVp(argc, vp);
+    ContextOptions oldContextOptions = ContextOptionsRef(cx);
+
+    RootedString str(cx);
+    JSAutoByteString opt;
+    for (unsigned i = 0; i < args.length(); ++i) {
+        str = ToString(cx, args[i]);
+        if (!str)
+            return false;
+
+        opt.clear();
+        if (!opt.encodeUtf8(cx, str))
+            return false;
+
+        if (strcmp(opt.ptr(), "strict") == 0)
+            ContextOptionsRef(cx).toggleExtraWarnings();
+        else if (strcmp(opt.ptr(), "werror") == 0)
+            ContextOptionsRef(cx).toggleWerror();
+        else if (strcmp(opt.ptr(), "strict_mode") == 0)
+            ContextOptionsRef(cx).toggleStrictMode();
+        else {
+            JS_ReportErrorUTF8(cx, "unknown option name '%s'. The valid names are "
+                               "strict, werror, and strict_mode.", opt.ptr());
+            return false;
+        }
+    }
+
+    char* names = nullptr;
+    if (oldContextOptions.extraWarnings()) {
+        names = JS_sprintf_append(names, "%s", "strict");
+        if (!names) {
+            JS_ReportOutOfMemory(cx);
+            return false;
+        }
+    }
+    if (oldContextOptions.werror()) {
+        names = JS_sprintf_append(names, "%s%s", names ? "," : "", "werror");
+        if (!names) {
+            JS_ReportOutOfMemory(cx);
+            return false;
+        }
+    }
+    if (names && oldContextOptions.strictMode()) {
+        names = JS_sprintf_append(names, "%s%s", names ? "," : "", "strict_mode");
+        if (!names) {
+            JS_ReportOutOfMemory(cx);
+            return false;
+        }
+    }
+
+    str = JS_NewStringCopyZ(cx, names);
+    free(names);
+    if (!str)
+        return false;
+
+    args.rval().setString(str);
+    return true;
+}
+
+static PersistentRootedValue *sScriptedInterruptCallback = nullptr;
+
+static bool
+XPCShellInterruptCallback(JSContext* cx)
+{
+    MOZ_ASSERT(sScriptedInterruptCallback->initialized());
+    RootedValue callback(cx, *sScriptedInterruptCallback);
+
+    // If no interrupt callback was set by script, no-op.
+    if (callback.isUndefined())
+        return true;
+
+    JSAutoCompartment ac(cx, &callback.toObject());
+    RootedValue rv(cx);
+    if (!JS_CallFunctionValue(cx, nullptr, callback, JS::HandleValueArray::empty(), &rv) ||
+        !rv.isBoolean())
+    {
+        NS_WARNING("Scripted interrupt callback failed! Terminating script.");
+        JS_ClearPendingException(cx);
+        return false;
+    }
+
+    return rv.toBoolean();
+}
+
+static bool
+SetInterruptCallback(JSContext* cx, unsigned argc, Value* vp)
+{
+    MOZ_ASSERT(sScriptedInterruptCallback->initialized());
+
+    // Sanity-check args.
+    JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+    if (args.length() != 1) {
+        JS_ReportErrorASCII(cx, "Wrong number of arguments");
+        return false;
+    }
+
+    // Allow callers to remove the interrupt callback by passing undefined.
+    if (args[0].isUndefined()) {
+        *sScriptedInterruptCallback = UndefinedValue();
+        return true;
+    }
+
+    // Otherwise, we should have a callable object.
+    if (!args[0].isObject() || !JS::IsCallable(&args[0].toObject())) {
+        JS_ReportErrorASCII(cx, "Argument must be callable");
+        return false;
+    }
+
+    *sScriptedInterruptCallback = args[0];
+
+    return true;
+}
+
+static bool
+SimulateActivityCallback(JSContext* cx, unsigned argc, Value* vp)
+{
+    // Sanity-check args.
+    JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+    if (args.length() != 1 || !args[0].isBoolean()) {
+        JS_ReportErrorASCII(cx, "Wrong number of arguments");
+        return false;
+    }
+    xpc::SimulateActivityCallback(args[0].toBoolean());
+    return true;
+}
+
+static bool
+RegisterAppManifest(JSContext* cx, unsigned argc, Value* vp)
+{
+    JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+    if (args.length() != 1) {
+        JS_ReportErrorASCII(cx, "Wrong number of arguments");
+        return false;
+    }
+    if (!args[0].isObject()) {
+        JS_ReportErrorASCII(cx, "Expected object as argument 1 to registerAppManifest");
+        return false;
+    }
+
+    Rooted<JSObject*> arg1(cx, &args[0].toObject());
+    nsCOMPtr<nsIFile> file;
+    nsresult rv = nsXPConnect::XPConnect()->
+        WrapJS(cx, arg1, NS_GET_IID(nsIFile), getter_AddRefs(file));
+    if (NS_FAILED(rv)) {
+        XPCThrower::Throw(rv, cx);
+        return false;
+    }
+    rv = XRE_AddManifestLocation(NS_APP_LOCATION, file);
+    if (NS_FAILED(rv)) {
+        XPCThrower::Throw(rv, cx);
+        return false;
+    }
+    return true;
+}
+
+static const JSFunctionSpec glob_functions[] = {
+    JS_FS("print",           Print,          0,0),
+    JS_FS("readline",        ReadLine,       1,0),
+    JS_FS("load",            Load,           1,0),
+    JS_FS("quit",            Quit,           0,0),
+    JS_FS("version",         Version,        1,0),
+    JS_FS("dumpXPC",         DumpXPC,        1,0),
+    JS_FS("dump",            Dump,           1,0),
+    JS_FS("gc",              GC,             0,0),
+#ifdef JS_GC_ZEAL
+    JS_FS("gczeal",          GCZeal,         1,0),
+#endif
+    JS_FS("options",         Options,        0,0),
+    JS_FS("sendCommand",     SendCommand,    1,0),
+    JS_FS("atob",            xpc::Atob,      1,0),
+    JS_FS("btoa",            xpc::Btoa,      1,0),
+    JS_FS("setInterruptCallback", SetInterruptCallback, 1,0),
+    JS_FS("simulateActivityCallback", SimulateActivityCallback, 1,0),
+    JS_FS("registerAppManifest", RegisterAppManifest, 1, 0),
+    JS_FS_END
+};
+
+static bool
+env_setProperty(JSContext* cx, HandleObject obj, HandleId id, MutableHandleValue vp,
+                ObjectOpResult& result)
+{
+/* XXX porting may be easy, but these don't seem to supply setenv by default */
+#if !defined SOLARIS
+    RootedString valstr(cx);
+    RootedString idstr(cx);
+    int rv;
+
+    RootedValue idval(cx);
+    if (!JS_IdToValue(cx, id, &idval))
+        return false;
+
+    idstr = ToString(cx, idval);
+    valstr = ToString(cx, vp);
+    if (!idstr || !valstr)
+        return false;
+    JSAutoByteString name(cx, idstr);
+    if (!name)
+        return false;
+    JSAutoByteString value(cx, valstr);
+    if (!value)
+        return false;
+#if defined XP_WIN || defined HPUX || defined OSF1 || defined SCO
+    {
+        char* waste = JS_smprintf("%s=%s", name.ptr(), value.ptr());
+        if (!waste) {
+            JS_ReportOutOfMemory(cx);
+            return false;
+        }
+        rv = putenv(waste);
+#ifdef XP_WIN
+        /*
+         * HPUX9 at least still has the bad old non-copying putenv.
+         *
+         * Per mail from <s.shanmuganathan@digital.com>, OSF1 also has a putenv
+         * that will crash if you pass it an auto char array (so it must place
+         * its argument directly in the char* environ[] array).
+         */
+        free(waste);
+#endif
+    }
+#else
+    rv = setenv(name.ptr(), value.ptr(), 1);
+#endif
+    if (rv < 0) {
+        name.clear();
+        value.clear();
+        if (!name.encodeUtf8(cx, idstr))
+            return false;
+        if (!value.encodeUtf8(cx, valstr))
+            return false;
+        JS_ReportErrorUTF8(cx, "can't set envariable %s to %s", name.ptr(), value.ptr());
+        return false;
+    }
+    vp.setString(valstr);
+#endif /* !defined SOLARIS */
+    return result.succeed();
+}
+
+static bool
+env_enumerate(JSContext* cx, HandleObject obj)
+{
+    static bool reflected;
+    char** evp;
+    char* name;
+    char* value;
+    RootedString valstr(cx);
+    bool ok;
+
+    if (reflected)
+        return true;
+
+    for (evp = (char**)JS_GetPrivate(obj); (name = *evp) != nullptr; evp++) {
+        value = strchr(name, '=');
+        if (!value)
+            continue;
+        *value++ = '\0';
+        valstr = JS_NewStringCopyZ(cx, value);
+        ok = valstr ? JS_DefineProperty(cx, obj, name, valstr, JSPROP_ENUMERATE) : false;
+        value[-1] = '=';
+        if (!ok)
+            return false;
+    }
+
+    reflected = true;
+    return true;
+}
+
+static bool
+env_resolve(JSContext* cx, HandleObject obj, HandleId id, bool* resolvedp)
+{
+    JSString* idstr;
+
+    RootedValue idval(cx);
+    if (!JS_IdToValue(cx, id, &idval))
+        return false;
+
+    idstr = ToString(cx, idval);
+    if (!idstr)
+        return false;
+    JSAutoByteString name(cx, idstr);
+    if (!name)
+        return false;
+    const char* value = getenv(name.ptr());
+    if (value) {
+        RootedString valstr(cx, JS_NewStringCopyZ(cx, value));
+        if (!valstr)
+            return false;
+        if (!JS_DefinePropertyById(cx, obj, id, valstr, JSPROP_ENUMERATE)) {
+            return false;
+        }
+        *resolvedp = true;
+    }
+    return true;
+}
+
+static const JSClassOps env_classOps = {
+    nullptr, nullptr, nullptr, env_setProperty,
+    env_enumerate, env_resolve
+};
+
+static const JSClass env_class = {
+    "environment", JSCLASS_HAS_PRIVATE,
+    &env_classOps
+};
+
+/***************************************************************************/
+
+typedef enum JSShellErrNum {
+#define MSG_DEF(name, number, count, exception, format) \
+    name = number,
+#include "jsshell.msg"
+#undef MSG_DEF
+    JSShellErr_Limit
+} JSShellErrNum;
+
+static const JSErrorFormatString jsShell_ErrorFormatString[JSShellErr_Limit] = {
+#define MSG_DEF(name, number, count, exception, format) \
+    { #name, format, count } ,
+#include "jsshell.msg"
+#undef MSG_DEF
+};
+
+static const JSErrorFormatString*
+my_GetErrorMessage(void* userRef, const unsigned errorNumber)
+{
+    if (errorNumber == 0 || errorNumber >= JSShellErr_Limit)
+        return nullptr;
+
+    return &jsShell_ErrorFormatString[errorNumber];
+}
+
+static bool
+ProcessLine(AutoJSAPI& jsapi, const char* buffer, int startline)
+{
+    JSContext* cx = jsapi.cx();
+    JS::RootedScript script(cx);
+    JS::RootedValue result(cx);
+    JS::CompileOptions options(cx);
+    options.setFileAndLine("typein", startline)
+           .setIsRunOnce(true);
+    if (!JS_CompileScript(cx, buffer, strlen(buffer), options, &script))
+        return false;
+    if (compileOnly)
+        return true;
+    if (!JS_ExecuteScript(cx, script, &result))
+        return false;
+
+    if (result.isUndefined())
+        return true;
+    RootedString str(cx);
+    if (!(str = ToString(cx, result)))
+        return false;
+    JSAutoByteString bytes;
+    if (!bytes.encodeLatin1(cx, str))
+        return false;
+
+    fprintf(gOutFile, "%s\n", bytes.ptr());
+    return true;
+}
+
+static bool
+ProcessFile(AutoJSAPI& jsapi, const char* filename, FILE* file, bool forceTTY)
+{
+    JSContext* cx = jsapi.cx();
+    JS::Rooted<JSObject*> global(cx, JS::CurrentGlobalOrNull(cx));
+    MOZ_ASSERT(global);
+
+    if (forceTTY) {
+        file = stdin;
+    } else if (!isatty(fileno(file))) {
+        /*
+         * It's not interactive - just execute it.
+         *
+         * Support the UNIX #! shell hack; gobble the first line if it starts
+         * with '#'.  TODO - this isn't quite compatible with sharp variables,
+         * as a legal js program (using sharp variables) might start with '#'.
+         * But that would require multi-character lookahead.
+         */
+        int ch = fgetc(file);
+        if (ch == '#') {
+            while ((ch = fgetc(file)) != EOF) {
+                if (ch == '\n' || ch == '\r')
+                    break;
+            }
+        }
+        ungetc(ch, file);
+
+        JS::RootedScript script(cx);
+        JS::RootedValue unused(cx);
+        JS::CompileOptions options(cx);
+        options.setUTF8(true)
+               .setFileAndLine(filename, 1)
+               .setIsRunOnce(true)
+               .setNoScriptRval(true);
+        if (!JS::Compile(cx, options, file, &script))
+            return false;
+        return compileOnly || JS_ExecuteScript(cx, script, &unused);
+    }
+
+    /* It's an interactive filehandle; drop into read-eval-print loop. */
+    int lineno = 1;
+    bool hitEOF = false;
+    do {
+        char buffer[4096];
+        char* bufp = buffer;
+        *bufp = '\0';
+
+        /*
+         * Accumulate lines until we get a 'compilable unit' - one that either
+         * generates an error (before running out of source) or that compiles
+         * cleanly.  This should be whenever we get a complete statement that
+         * coincides with the end of a line.
+         */
+        int startline = lineno;
+        do {
+            if (!GetLine(cx, bufp, file, startline == lineno ? "js> " : "")) {
+                hitEOF = true;
+                break;
+            }
+            bufp += strlen(bufp);
+            lineno++;
+        } while (!JS_BufferIsCompilableUnit(cx, global, buffer, strlen(buffer)));
+
+        if (!ProcessLine(jsapi, buffer, startline))
+            jsapi.ReportException();
+    } while (!hitEOF && !gQuitting);
+
+    fprintf(gOutFile, "\n");
+    return true;
+}
+
+static bool
+Process(AutoJSAPI& jsapi, const char* filename, bool forceTTY)
+{
+    FILE* file;
+
+    if (forceTTY || !filename || strcmp(filename, "-") == 0) {
+        file = stdin;
+    } else {
+        file = fopen(filename, "r");
+        if (!file) {
+            /*
+             * Use Latin1 variant here because the encoding of the return value
+             * of strerror function can be non-UTF-8.
+             */
+            JS_ReportErrorNumberLatin1(jsapi.cx(), my_GetErrorMessage, nullptr,
+                                       JSSMSG_CANT_OPEN,
+                                       filename, strerror(errno));
+            gExitCode = EXITCODE_FILE_NOT_FOUND;
+            return false;
+        }
+    }
+
+    bool ok = ProcessFile(jsapi, filename, file, forceTTY);
+    if (file != stdin)
+        fclose(file);
+    return ok;
+}
+
+static int
+usage()
+{
+    fprintf(gErrFile, "%s\n", JS_GetImplementationVersion());
+    fprintf(gErrFile, "usage: xpcshell [-g gredir] [-a appdir] [-r manifest]... [-WwxiCSsmIp] [-v version] [-f scriptfile] [-e script] [scriptfile] [scriptarg...]\n");
+    return 2;
+}
+
+static bool
+printUsageAndSetExitCode()
+{
+    gExitCode = usage();
+    return false;
+}
+
+static void
+ProcessArgsForCompartment(JSContext* cx, char** argv, int argc)
+{
+    for (int i = 0; i < argc; i++) {
+        if (argv[i][0] != '-' || argv[i][1] == '\0')
+            break;
+
+        switch (argv[i][1]) {
+          case 'v':
+          case 'f':
+          case 'e':
+            if (++i == argc)
+                return;
+            break;
+        case 'S':
+            ContextOptionsRef(cx).toggleWerror();
+            MOZ_FALLTHROUGH; // because -S implies -s
+        case 's':
+            ContextOptionsRef(cx).toggleExtraWarnings();
+            break;
+        case 'I':
+            ContextOptionsRef(cx).toggleIon()
+                                 .toggleAsmJS()
+                                 .toggleWasm();
+            break;
+        }
+    }
+}
+
+static bool
+ProcessArgs(AutoJSAPI& jsapi, char** argv, int argc, XPCShellDirProvider* aDirProvider)
+{
+    JSContext* cx = jsapi.cx();
+    const char rcfilename[] = "xpcshell.js";
+    FILE* rcfile;
+    int rootPosition;
+    JS::Rooted<JSObject*> argsObj(cx);
+    char* filename = nullptr;
+    bool isInteractive = true;
+    bool forceTTY = false;
+
+    rcfile = fopen(rcfilename, "r");
+    if (rcfile) {
+        printf("[loading '%s'...]\n", rcfilename);
+        bool ok = ProcessFile(jsapi, rcfilename, rcfile, false);
+        fclose(rcfile);
+        if (!ok) {
+            return false;
+        }
+    }
+
+    JS::Rooted<JSObject*> global(cx, JS::CurrentGlobalOrNull(cx));
+
+    /*
+     * Scan past all optional arguments so we can create the arguments object
+     * before processing any -f options, which must interleave properly with
+     * -v and -w options.  This requires two passes, and without getopt, we'll
+     * have to keep the option logic here and in the second for loop in sync.
+     * First of all, find out the first argument position which will be passed
+     * as a script file to be executed.
+     */
+    for (rootPosition = 0; rootPosition < argc; rootPosition++) {
+        if (argv[rootPosition][0] != '-' || argv[rootPosition][1] == '\0') {
+            ++rootPosition;
+            break;
+        }
+
+        bool isPairedFlag =
+            argv[rootPosition][0] != '\0' &&
+            (argv[rootPosition][1] == 'v' ||
+             argv[rootPosition][1] == 'f' ||
+             argv[rootPosition][1] == 'e');
+        if (isPairedFlag && rootPosition < argc - 1) {
+          ++rootPosition; // Skip over the 'foo' portion of |-v foo|, |-f foo|, or |-e foo|.
+        }
+    }
+
+    /*
+     * Create arguments early and define it to root it, so it's safe from any
+     * GC calls nested below, and so it is available to -f <file> arguments.
+     */
+    argsObj = JS_NewArrayObject(cx, 0);
+    if (!argsObj)
+        return 1;
+    if (!JS_DefineProperty(cx, global, "arguments", argsObj, 0))
+        return 1;
+
+    for (int j = 0, length = argc - rootPosition; j < length; j++) {
+        RootedString str(cx, JS_NewStringCopyZ(cx, argv[rootPosition++]));
+        if (!str ||
+            !JS_DefineElement(cx, argsObj, j, str, JSPROP_ENUMERATE)) {
+            return 1;
+        }
+    }
+
+    for (int i = 0; i < argc; i++) {
+        if (argv[i][0] != '-' || argv[i][1] == '\0') {
+            filename = argv[i++];
+            isInteractive = false;
+            break;
+        }
+        switch (argv[i][1]) {
+        case 'v':
+            if (++i == argc) {
+                return printUsageAndSetExitCode();
+            }
+            JS_SetVersionForCompartment(js::GetContextCompartment(cx),
+                                        JSVersion(atoi(argv[i])));
+            break;
+        case 'W':
+            reportWarnings = false;
+            break;
+        case 'w':
+            reportWarnings = true;
+            break;
+        case 'x':
+            break;
+        case 'd':
+            /* This used to try to turn on the debugger. */
+            break;
+        case 'm':
+            break;
+        case 'f':
+            if (++i == argc) {
+                return printUsageAndSetExitCode();
+            }
+            if (!Process(jsapi, argv[i], false))
+                return false;
+            /*
+             * XXX: js -f foo.js should interpret foo.js and then
+             * drop into interactive mode, but that breaks test
+             * harness. Just execute foo.js for now.
+             */
+            isInteractive = false;
+            break;
+        case 'i':
+            isInteractive = forceTTY = true;
+            break;
+        case 'e':
+        {
+            RootedValue rval(cx);
+
+            if (++i == argc) {
+                return printUsageAndSetExitCode();
+            }
+
+            JS::CompileOptions opts(cx);
+            opts.setFileAndLine("-e", 1);
+            JS::Evaluate(cx, opts, argv[i], strlen(argv[i]), &rval);
+
+            isInteractive = false;
+            break;
+        }
+        case 'C':
+            compileOnly = true;
+            isInteractive = false;
+            break;
+        case 'S':
+        case 's':
+        case 'I':
+            // These options are processed in ProcessArgsForCompartment.
+            break;
+        case 'p':
+        {
+          // plugins path
+          char* pluginPath = argv[++i];
+          nsCOMPtr<nsIFile> pluginsDir;
+          if (NS_FAILED(XRE_GetFileFromPath(pluginPath, getter_AddRefs(pluginsDir)))) {
+              fprintf(gErrFile, "Couldn't use given plugins dir.\n");
+              return printUsageAndSetExitCode();
+          }
+          aDirProvider->SetPluginDir(pluginsDir);
+          break;
+        }
+        default:
+            return printUsageAndSetExitCode();
+        }
+    }
+
+    if (filename || isInteractive)
+        return Process(jsapi, filename, forceTTY);
+    return true;
+}
+
+/***************************************************************************/
+
+// #define TEST_InitClassesWithNewWrappedGlobal
+
+#ifdef TEST_InitClassesWithNewWrappedGlobal
+// XXX hacky test code...
+#include "xpctest.h"
+
+class TestGlobal : public nsIXPCTestNoisy, public nsIXPCScriptable
+{
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCTESTNOISY
+    NS_DECL_NSIXPCSCRIPTABLE
+
+    TestGlobal(){}
+};
+
+NS_IMPL_ISUPPORTS(TestGlobal, nsIXPCTestNoisy, nsIXPCScriptable)
+
+// The nsIXPCScriptable map declaration that will generate stubs for us...
+#define XPC_MAP_CLASSNAME           TestGlobal
+#define XPC_MAP_QUOTED_CLASSNAME   "TestGlobal"
+#define XPC_MAP_FLAGS               nsIXPCScriptable::USE_JSSTUB_FOR_ADDPROPERTY |\
+                                    nsIXPCScriptable::USE_JSSTUB_FOR_DELPROPERTY |\
+                                    nsIXPCScriptable::USE_JSSTUB_FOR_SETPROPERTY
+#include "xpc_map_end.h" /* This will #undef the above */
+
+NS_IMETHODIMP TestGlobal::Squawk() {return NS_OK;}
+
+#endif
+
+// uncomment to install the test 'this' translator
+// #define TEST_TranslateThis
+
+#ifdef TEST_TranslateThis
+
+#include "xpctest.h"
+
+class nsXPCFunctionThisTranslator : public nsIXPCFunctionThisTranslator
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIXPCFUNCTIONTHISTRANSLATOR
+
+  nsXPCFunctionThisTranslator();
+  virtual ~nsXPCFunctionThisTranslator();
+  /* additional members */
+};
+
+/* Implementation file */
+NS_IMPL_ISUPPORTS(nsXPCFunctionThisTranslator, nsIXPCFunctionThisTranslator)
+
+nsXPCFunctionThisTranslator::nsXPCFunctionThisTranslator()
+{
+}
+
+nsXPCFunctionThisTranslator::~nsXPCFunctionThisTranslator()
+{
+}
+
+NS_IMETHODIMP
+nsXPCFunctionThisTranslator::TranslateThis(nsISupports* aInitialThis,
+                                           nsISupports** _retval)
+{
+    nsCOMPtr<nsISupports> temp = aInitialThis;
+    temp.forget(_retval);
+    return NS_OK;
+}
+
+#endif
+
+static bool
+GetCurrentWorkingDirectory(nsAString& workingDirectory)
+{
+#if !defined(XP_WIN) && !defined(XP_UNIX)
+    //XXX: your platform should really implement this
+    return false;
+#elif XP_WIN
+    DWORD requiredLength = GetCurrentDirectoryW(0, nullptr);
+    workingDirectory.SetLength(requiredLength);
+    GetCurrentDirectoryW(workingDirectory.Length(),
+                         (LPWSTR)workingDirectory.BeginWriting());
+    // we got a trailing null there
+    workingDirectory.SetLength(requiredLength);
+    workingDirectory.Replace(workingDirectory.Length() - 1, 1, L'\\');
+#elif defined(XP_UNIX)
+    nsAutoCString cwd;
+    // 1024 is just a guess at a sane starting value
+    size_t bufsize = 1024;
+    char* result = nullptr;
+    while (result == nullptr) {
+        cwd.SetLength(bufsize);
+        result = getcwd(cwd.BeginWriting(), cwd.Length());
+        if (!result) {
+            if (errno != ERANGE)
+                return false;
+            // need to make the buffer bigger
+            bufsize *= 2;
+        }
+    }
+    // size back down to the actual string length
+    cwd.SetLength(strlen(result) + 1);
+    cwd.Replace(cwd.Length() - 1, 1, '/');
+    workingDirectory = NS_ConvertUTF8toUTF16(cwd);
+#endif
+    return true;
+}
+
+static JSSecurityCallbacks shellSecurityCallbacks;
+
+int
+XRE_XPCShellMain(int argc, char** argv, char** envp,
+                 const XREShellData* aShellData)
+{
+    MOZ_ASSERT(aShellData);
+
+    JSContext* cx;
+    int result = 0;
+    nsresult rv;
+
+    gErrFile = stderr;
+    gOutFile = stdout;
+    gInFile = stdin;
+
+    NS_LogInit();
+
+    mozilla::LogModule::Init();
+
+    // A initializer to initialize histogram collection
+    // used by telemetry.
+    UniquePtr<base::StatisticsRecorder> telStats =
+       MakeUnique<base::StatisticsRecorder>();
+
+    if (PR_GetEnv("MOZ_CHAOSMODE")) {
+        ChaosFeature feature = ChaosFeature::Any;
+        long featureInt = strtol(PR_GetEnv("MOZ_CHAOSMODE"), nullptr, 16);
+        if (featureInt) {
+            // NOTE: MOZ_CHAOSMODE=0 or a non-hex value maps to Any feature.
+            feature = static_cast<ChaosFeature>(featureInt);
+        }
+        ChaosMode::SetChaosFeature(feature);
+    }
+
+    if (ChaosMode::isActive(ChaosFeature::Any)) {
+        printf_stderr("*** You are running in chaos test mode. See ChaosMode.h. ***\n");
+    }
+
+    nsCOMPtr<nsIFile> appFile;
+    rv = XRE_GetBinaryPath(argv[0], getter_AddRefs(appFile));
+    if (NS_FAILED(rv)) {
+        printf("Couldn't find application file.\n");
+        return 1;
+    }
+    nsCOMPtr<nsIFile> appDir;
+    rv = appFile->GetParent(getter_AddRefs(appDir));
+    if (NS_FAILED(rv)) {
+        printf("Couldn't get application directory.\n");
+        return 1;
+    }
+
+    XPCShellDirProvider dirprovider;
+
+    dirprovider.SetAppFile(appFile);
+
+    nsCOMPtr<nsIFile> greDir;
+    if (argc > 1 && !strcmp(argv[1], "-g")) {
+        if (argc < 3)
+            return usage();
+
+        rv = XRE_GetFileFromPath(argv[2], getter_AddRefs(greDir));
+        if (NS_FAILED(rv)) {
+            printf("Couldn't use given GRE dir.\n");
+            return 1;
+        }
+
+        dirprovider.SetGREDirs(greDir);
+
+        argc -= 2;
+        argv += 2;
+    } else {
+#ifdef XP_MACOSX
+        // On OSX, the GreD needs to point to Contents/Resources in the .app
+        // bundle. Libraries will be loaded at a relative path to GreD, i.e.
+        // ../MacOS.
+        nsCOMPtr<nsIFile> tmpDir;
+        XRE_GetFileFromPath(argv[0], getter_AddRefs(greDir));
+        greDir->GetParent(getter_AddRefs(tmpDir));
+        tmpDir->Clone(getter_AddRefs(greDir));
+        tmpDir->SetNativeLeafName(NS_LITERAL_CSTRING("Resources"));
+        bool dirExists = false;
+        tmpDir->Exists(&dirExists);
+        if (dirExists) {
+            greDir = tmpDir.forget();
+        }
+        dirprovider.SetGREDirs(greDir);
+#else
+        nsAutoString workingDir;
+        if (!GetCurrentWorkingDirectory(workingDir)) {
+            printf("GetCurrentWorkingDirectory failed.\n");
+            return 1;
+        }
+        rv = NS_NewLocalFile(workingDir, true, getter_AddRefs(greDir));
+        if (NS_FAILED(rv)) {
+            printf("NS_NewLocalFile failed.\n");
+            return 1;
+        }
+#endif
+    }
+
+    if (argc > 1 && !strcmp(argv[1], "-a")) {
+        if (argc < 3)
+            return usage();
+
+        nsCOMPtr<nsIFile> dir;
+        rv = XRE_GetFileFromPath(argv[2], getter_AddRefs(dir));
+        if (NS_SUCCEEDED(rv)) {
+            appDir = do_QueryInterface(dir, &rv);
+            dirprovider.SetAppDir(appDir);
+        }
+        if (NS_FAILED(rv)) {
+            printf("Couldn't use given appdir.\n");
+            return 1;
+        }
+        argc -= 2;
+        argv += 2;
+    }
+
+    while (argc > 1 && !strcmp(argv[1], "-r")) {
+        if (argc < 3)
+            return usage();
+
+        nsCOMPtr<nsIFile> lf;
+        rv = XRE_GetFileFromPath(argv[2], getter_AddRefs(lf));
+        if (NS_FAILED(rv)) {
+            printf("Couldn't get manifest file.\n");
+            return 1;
+        }
+        XRE_AddManifestLocation(NS_APP_LOCATION, lf);
+
+        argc -= 2;
+        argv += 2;
+    }
+
+#ifdef MOZ_CRASHREPORTER
+    const char* val = getenv("MOZ_CRASHREPORTER");
+    if (val && *val) {
+        rv = CrashReporter::SetExceptionHandler(greDir, true);
+        if (NS_FAILED(rv)) {
+            printf("CrashReporter::SetExceptionHandler failed!\n");
+            return 1;
+        }
+        MOZ_ASSERT(CrashReporter::GetEnabled());
+    }
+#endif
+
+    {
+        if (argc > 1 && !strcmp(argv[1], "--greomni")) {
+            nsCOMPtr<nsIFile> greOmni;
+            nsCOMPtr<nsIFile> appOmni;
+            XRE_GetFileFromPath(argv[2], getter_AddRefs(greOmni));
+            if (argc > 3 && !strcmp(argv[3], "--appomni")) {
+                XRE_GetFileFromPath(argv[4], getter_AddRefs(appOmni));
+                argc-=2;
+                argv+=2;
+            } else {
+                appOmni = greOmni;
+            }
+
+            XRE_InitOmnijar(greOmni, appOmni);
+            argc-=2;
+            argv+=2;
+        }
+
+        nsCOMPtr<nsIServiceManager> servMan;
+        rv = NS_InitXPCOM2(getter_AddRefs(servMan), appDir, &dirprovider);
+        if (NS_FAILED(rv)) {
+            printf("NS_InitXPCOM2 failed!\n");
+            return 1;
+        }
+
+        // xpc::ErrorReport::LogToConsoleWithStack needs this to print errors
+        // to stderr.
+        Preferences::SetBool("browser.dom.window.dump.enabled", true);
+
+        AutoJSAPI jsapi;
+        jsapi.Init();
+        cx = jsapi.cx();
+
+        // Override the default XPConnect interrupt callback. We could store the
+        // old one and restore it before shutting down, but there's not really a
+        // reason to bother.
+        sScriptedInterruptCallback = new PersistentRootedValue;
+        sScriptedInterruptCallback->init(cx, UndefinedValue());
+
+        JS_AddInterruptCallback(cx, XPCShellInterruptCallback);
+
+        argc--;
+        argv++;
+        ProcessArgsForCompartment(cx, argv, argc);
+
+        nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID());
+        if (!xpc) {
+            printf("failed to get nsXPConnect service!\n");
+            return 1;
+        }
+
+        nsCOMPtr<nsIPrincipal> systemprincipal;
+        // Fetch the system principal and store it away in a global, to use for
+        // script compilation in Load() and ProcessFile() (including interactive
+        // eval loop)
+        {
+
+            nsCOMPtr<nsIScriptSecurityManager> securityManager =
+                do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
+            if (NS_SUCCEEDED(rv) && securityManager) {
+                rv = securityManager->GetSystemPrincipal(getter_AddRefs(systemprincipal));
+                if (NS_FAILED(rv)) {
+                    fprintf(gErrFile, "+++ Failed to obtain SystemPrincipal from ScriptSecurityManager service.\n");
+                } else {
+                    // fetch the JS principals and stick in a global
+                    gJSPrincipals = nsJSPrincipals::get(systemprincipal);
+                    JS_HoldPrincipals(gJSPrincipals);
+                }
+            } else {
+                fprintf(gErrFile, "+++ Failed to get ScriptSecurityManager service, running without principals");
+            }
+        }
+
+        const JSSecurityCallbacks* scb = JS_GetSecurityCallbacks(cx);
+        MOZ_ASSERT(scb, "We are assuming that nsScriptSecurityManager::Init() has been run");
+        shellSecurityCallbacks = *scb;
+        JS_SetSecurityCallbacks(cx, &shellSecurityCallbacks);
+
+#ifdef TEST_TranslateThis
+        nsCOMPtr<nsIXPCFunctionThisTranslator>
+            translator(new nsXPCFunctionThisTranslator);
+        xpc->SetFunctionThisTranslator(NS_GET_IID(nsITestXPCFunctionCallback), translator);
+#endif
+
+        RefPtr<BackstagePass> backstagePass;
+        rv = NS_NewBackstagePass(getter_AddRefs(backstagePass));
+        if (NS_FAILED(rv)) {
+            fprintf(gErrFile, "+++ Failed to create BackstagePass: %8x\n",
+                    static_cast<uint32_t>(rv));
+            return 1;
+        }
+
+        // Make the default XPCShell global use a fresh zone (rather than the
+        // System Zone) to improve cross-zone test coverage.
+        JS::CompartmentOptions options;
+        options.creationOptions().setZone(JS::FreshZone);
+        if (xpc::SharedMemoryEnabled())
+            options.creationOptions().setSharedMemoryAndAtomicsEnabled(true);
+        options.behaviors().setVersion(JSVERSION_LATEST);
+        nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
+        rv = xpc->InitClassesWithNewWrappedGlobal(cx,
+                                                  static_cast<nsIGlobalObject*>(backstagePass),
+                                                  systemprincipal,
+                                                  0,
+                                                  options,
+                                                  getter_AddRefs(holder));
+        if (NS_FAILED(rv))
+            return 1;
+
+        // Initialize graphics prefs on the main thread, if not already done
+        gfxPrefs::GetSingleton();
+        // Initialize e10s check on the main thread, if not already done
+        BrowserTabsRemoteAutostart();
+#ifdef XP_WIN
+        // Plugin may require audio session if installed plugin can initialize
+        // asynchronized.
+        AutoAudioSession audioSession;
+
+#if defined(MOZ_SANDBOX)
+        // Required for sandboxed child processes.
+        if (aShellData->sandboxBrokerServices) {
+          SandboxBroker::Initialize(aShellData->sandboxBrokerServices);
+        } else {
+          NS_WARNING("Failed to initialize broker services, sandboxed "
+                     "processes will fail to start.");
+        }
+#endif
+#endif
+
+        {
+            JS::Rooted<JSObject*> glob(cx, holder->GetJSObject());
+            if (!glob) {
+                return 1;
+            }
+
+            // Even if we're building in a configuration where source is
+            // discarded, there's no reason to do that on XPCShell, and doing so
+            // might break various automation scripts.
+            JS::CompartmentBehaviorsRef(glob).setDiscardSource(false);
+
+            backstagePass->SetGlobalObject(glob);
+
+            JSAutoCompartment ac(cx, glob);
+
+            if (!JS_InitReflectParse(cx, glob)) {
+                return 1;
+            }
+
+            if (!JS_DefineFunctions(cx, glob, glob_functions) ||
+                !JS_DefineProfilingFunctions(cx, glob)) {
+                return 1;
+            }
+
+            JS::Rooted<JSObject*> envobj(cx);
+            envobj = JS_DefineObject(cx, glob, "environment", &env_class);
+            if (!envobj) {
+                return 1;
+            }
+
+            JS_SetPrivate(envobj, envp);
+
+            nsAutoString workingDirectory;
+            if (GetCurrentWorkingDirectory(workingDirectory))
+                gWorkingDirectory = &workingDirectory;
+
+            JS_DefineProperty(cx, glob, "__LOCATION__", JS::UndefinedHandleValue,
+                              JSPROP_SHARED,
+                              GetLocationProperty,
+                              nullptr);
+
+            {
+                // We are almost certainly going to run script here, so we need an
+                // AutoEntryScript. This is Gecko-specific and not in any spec.
+                AutoEntryScript aes(backstagePass, "xpcshell argument processing");
+
+                // If an exception is thrown, we'll set our return code
+                // appropriately, and then let the AutoEntryScript destructor report
+                // the error to the console.
+                if (!ProcessArgs(aes, argv, argc, &dirprovider)) {
+                    if (gExitCode) {
+                        result = gExitCode;
+                    } else if (gQuitting) {
+                        result = 0;
+                    } else {
+                        result = EXITCODE_RUNTIME_ERROR;
+                    }
+                }
+            }
+
+            JS_DropPrincipals(cx, gJSPrincipals);
+            JS_SetAllNonReservedSlotsToUndefined(cx, glob);
+            JS_SetAllNonReservedSlotsToUndefined(cx, JS_GlobalLexicalEnvironment(glob));
+            JS_GC(cx);
+        }
+        JS_GC(cx);
+    } // this scopes the nsCOMPtrs
+
+    if (!XRE_ShutdownTestShell())
+        NS_ERROR("problem shutting down testshell");
+
+    // no nsCOMPtrs are allowed to be alive when you call NS_ShutdownXPCOM
+    rv = NS_ShutdownXPCOM( nullptr );
+    MOZ_ASSERT(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
+
+#ifdef TEST_CALL_ON_WRAPPED_JS_AFTER_SHUTDOWN
+    // test of late call and release (see above)
+    JSContext* bogusCX;
+    bogus->Peek(&bogusCX);
+    bogus = nullptr;
+#endif
+
+    telStats = nullptr;
+    appDir = nullptr;
+    appFile = nullptr;
+    dirprovider.ClearGREDirs();
+    dirprovider.ClearAppDir();
+    dirprovider.ClearPluginDir();
+    dirprovider.ClearAppFile();
+
+#ifdef MOZ_CRASHREPORTER
+    // Shut down the crashreporter service to prevent leaking some strings it holds.
+    if (CrashReporter::GetEnabled())
+        CrashReporter::UnsetExceptionHandler();
+#endif
+
+    NS_LogTerm();
+
+    return result;
+}
+
+void
+XPCShellDirProvider::SetGREDirs(nsIFile* greDir)
+{
+    mGREDir = greDir;
+    mGREDir->Clone(getter_AddRefs(mGREBinDir));
+#ifdef XP_MACOSX
+    nsAutoCString leafName;
+    mGREDir->GetNativeLeafName(leafName);
+    if (leafName.Equals("Resources")) {
+        mGREBinDir->SetNativeLeafName(NS_LITERAL_CSTRING("MacOS"));
+    }
+#endif
+}
+
+void
+XPCShellDirProvider::SetAppFile(nsIFile* appFile)
+{
+    mAppFile = appFile;
+}
+
+void
+XPCShellDirProvider::SetAppDir(nsIFile* appDir)
+{
+    mAppDir = appDir;
+}
+
+void
+XPCShellDirProvider::SetPluginDir(nsIFile* pluginDir)
+{
+    mPluginDir = pluginDir;
+}
+
+NS_IMETHODIMP_(MozExternalRefCountType)
+XPCShellDirProvider::AddRef()
+{
+    return 2;
+}
+
+NS_IMETHODIMP_(MozExternalRefCountType)
+XPCShellDirProvider::Release()
+{
+    return 1;
+}
+
+NS_IMPL_QUERY_INTERFACE(XPCShellDirProvider,
+                        nsIDirectoryServiceProvider,
+                        nsIDirectoryServiceProvider2)
+
+NS_IMETHODIMP
+XPCShellDirProvider::GetFile(const char* prop, bool* persistent,
+                             nsIFile* *result)
+{
+    if (mGREDir && !strcmp(prop, NS_GRE_DIR)) {
+        *persistent = true;
+        return mGREDir->Clone(result);
+    } else if (mGREBinDir && !strcmp(prop, NS_GRE_BIN_DIR)) {
+        *persistent = true;
+        return mGREBinDir->Clone(result);
+    } else if (mAppFile && !strcmp(prop, XRE_EXECUTABLE_FILE)) {
+        *persistent = true;
+        return mAppFile->Clone(result);
+    } else if (mGREDir && !strcmp(prop, NS_APP_PREF_DEFAULTS_50_DIR)) {
+        nsCOMPtr<nsIFile> file;
+        *persistent = true;
+        if (NS_FAILED(mGREDir->Clone(getter_AddRefs(file))) ||
+            NS_FAILED(file->AppendNative(NS_LITERAL_CSTRING("defaults"))) ||
+            NS_FAILED(file->AppendNative(NS_LITERAL_CSTRING("pref"))))
+            return NS_ERROR_FAILURE;
+        file.forget(result);
+        return NS_OK;
+    }
+
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+XPCShellDirProvider::GetFiles(const char* prop, nsISimpleEnumerator* *result)
+{
+    if (mGREDir && !strcmp(prop, "ChromeML")) {
+        nsCOMArray<nsIFile> dirs;
+
+        nsCOMPtr<nsIFile> file;
+        mGREDir->Clone(getter_AddRefs(file));
+        file->AppendNative(NS_LITERAL_CSTRING("chrome"));
+        dirs.AppendObject(file);
+
+        nsresult rv = NS_GetSpecialDirectory(NS_APP_CHROME_DIR,
+                                             getter_AddRefs(file));
+        if (NS_SUCCEEDED(rv))
+            dirs.AppendObject(file);
+
+        return NS_NewArrayEnumerator(result, dirs);
+    } else if (!strcmp(prop, NS_APP_PREFS_DEFAULTS_DIR_LIST)) {
+        nsCOMArray<nsIFile> dirs;
+        nsCOMPtr<nsIFile> appDir;
+        bool exists;
+        if (mAppDir &&
+            NS_SUCCEEDED(mAppDir->Clone(getter_AddRefs(appDir))) &&
+            NS_SUCCEEDED(appDir->AppendNative(NS_LITERAL_CSTRING("defaults"))) &&
+            NS_SUCCEEDED(appDir->AppendNative(NS_LITERAL_CSTRING("preferences"))) &&
+            NS_SUCCEEDED(appDir->Exists(&exists)) && exists) {
+            dirs.AppendObject(appDir);
+            return NS_NewArrayEnumerator(result, dirs);
+        }
+        return NS_ERROR_FAILURE;
+    } else if (!strcmp(prop, NS_APP_PLUGINS_DIR_LIST)) {
+        nsCOMArray<nsIFile> dirs;
+        // Add the test plugin location passed in by the caller or through
+        // runxpcshelltests.
+        if (mPluginDir) {
+            dirs.AppendObject(mPluginDir);
+        // If there was no path specified, default to the one set up by automation
+        } else {
+            nsCOMPtr<nsIFile> file;
+            bool exists;
+            // We have to add this path, buildbot copies the test plugin directory
+            // to (app)/bin when unpacking test zips.
+            if (mGREDir) {
+                mGREDir->Clone(getter_AddRefs(file));
+                if (NS_SUCCEEDED(mGREDir->Clone(getter_AddRefs(file)))) {
+                    file->AppendNative(NS_LITERAL_CSTRING("plugins"));
+                    if (NS_SUCCEEDED(file->Exists(&exists)) && exists) {
+                        dirs.AppendObject(file);
+                    }
+                }
+            }
+        }
+        return NS_NewArrayEnumerator(result, dirs);
+    }
+    return NS_ERROR_FAILURE;
+}
diff --git a/js/xpconnect/src/XPCString.cpp b/js/xpconnect/src/XPCString.cpp
new file mode 100644
index 000000000..42a57744e
--- /dev/null
+++ b/js/xpconnect/src/XPCString.cpp
@@ -0,0 +1,143 @@
+/* -*- 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/. */
+
+/*
+ * Infrastructure for sharing DOMString data with JSStrings.
+ *
+ * Importing an nsAString into JS:
+ * If possible (GetSharedBufferHandle works) use the external string support in
+ * JS to create a JSString that points to the readable's buffer.  We keep a
+ * reference to the buffer handle until the JSString is finalized.
+ *
+ * Exporting a JSString as an nsAReadable:
+ * Wrap the JSString with a root-holding XPCJSReadableStringWrapper, which roots
+ * the string and exposes its buffer via the nsAString interface, as
+ * well as providing refcounting support.
+ */
+
+#include "nsAutoPtr.h"
+#include "nscore.h"
+#include "nsString.h"
+#include "nsStringBuffer.h"
+#include "jsapi.h"
+#include "xpcpublic.h"
+
+using namespace JS;
+
+// static
+void
+XPCStringConvert::FreeZoneCache(JS::Zone* zone)
+{
+    // Put the zone user data into an AutoPtr (which will do the cleanup for us),
+    // and null out the user data (which may already be null).
+    nsAutoPtr<ZoneStringCache> cache(static_cast<ZoneStringCache*>(JS_GetZoneUserData(zone)));
+    JS_SetZoneUserData(zone, nullptr);
+}
+
+// static
+void
+XPCStringConvert::ClearZoneCache(JS::Zone* zone)
+{
+    // Although we clear the cache in FinalizeDOMString if needed, we also clear
+    // the cache here to avoid a dangling JSString* pointer when compacting GC
+    // moves the external string in memory.
+
+    ZoneStringCache* cache = static_cast<ZoneStringCache*>(JS_GetZoneUserData(zone));
+    if (cache) {
+        cache->mBuffer = nullptr;
+        cache->mLength = 0;
+        cache->mString = nullptr;
+    }
+}
+
+// static
+void
+XPCStringConvert::FinalizeLiteral(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars)
+{
+}
+
+const JSStringFinalizer XPCStringConvert::sLiteralFinalizer =
+    { XPCStringConvert::FinalizeLiteral };
+
+// static
+void
+XPCStringConvert::FinalizeDOMString(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars)
+{
+    nsStringBuffer* buf = nsStringBuffer::FromData(chars);
+
+    // Clear the ZoneStringCache if needed, as this can be called outside GC
+    // when flattening an external string.
+    ZoneStringCache* cache = static_cast<ZoneStringCache*>(JS_GetZoneUserData(zone));
+    if (cache && cache->mBuffer == buf) {
+        cache->mBuffer = nullptr;
+        cache->mLength = 0;
+        cache->mString = nullptr;
+    }
+
+    buf->Release();
+}
+
+const JSStringFinalizer XPCStringConvert::sDOMStringFinalizer =
+    { XPCStringConvert::FinalizeDOMString };
+
+// convert a readable to a JSString, copying string data
+// static
+bool
+XPCStringConvert::ReadableToJSVal(JSContext* cx,
+                                  const nsAString& readable,
+                                  nsStringBuffer** sharedBuffer,
+                                  MutableHandleValue vp)
+{
+    *sharedBuffer = nullptr;
+
+    uint32_t length = readable.Length();
+
+    if (readable.IsLiteral()) {
+        JSString* str = JS_NewExternalString(cx,
+                                             static_cast<const char16_t*>(readable.BeginReading()),
+                                             length, &sLiteralFinalizer);
+        if (!str)
+            return false;
+        vp.setString(str);
+        return true;
+    }
+
+    nsStringBuffer* buf = nsStringBuffer::FromString(readable);
+    if (buf) {
+        bool shared;
+        if (!StringBufferToJSVal(cx, buf, length, vp, &shared))
+            return false;
+        if (shared)
+            *sharedBuffer = buf;
+        return true;
+    }
+
+    // blech, have to copy.
+    JSString* str = JS_NewUCStringCopyN(cx, readable.BeginReading(), length);
+    if (!str)
+        return false;
+    vp.setString(str);
+    return true;
+}
+
+namespace xpc {
+
+bool
+NonVoidStringToJsval(JSContext* cx, nsAString& str, MutableHandleValue rval)
+{
+    nsStringBuffer* sharedBuffer;
+    if (!XPCStringConvert::ReadableToJSVal(cx, str, &sharedBuffer, rval))
+      return false;
+
+    if (sharedBuffer) {
+        // The string was shared but ReadableToJSVal didn't addref it.
+        // Move the ownership from str to jsstr.
+        str.ForgetSharedBuffer();
+    }
+    return true;
+}
+
+} // namespace xpc
diff --git a/js/xpconnect/src/XPCThrower.cpp b/js/xpconnect/src/XPCThrower.cpp
new file mode 100644
index 000000000..4a37e1554
--- /dev/null
+++ b/js/xpconnect/src/XPCThrower.cpp
@@ -0,0 +1,179 @@
+/* -*- 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/. */
+
+/* Code for throwing errors into JavaScript. */
+
+#include "xpcprivate.h"
+#include "XPCWrapper.h"
+#include "jsprf.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/Exceptions.h"
+#include "nsStringGlue.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+bool XPCThrower::sVerbose = true;
+
+// static
+void
+XPCThrower::Throw(nsresult rv, JSContext* cx)
+{
+    const char* format;
+    if (JS_IsExceptionPending(cx))
+        return;
+    if (!nsXPCException::NameAndFormatForNSResult(rv, nullptr, &format))
+        format = "";
+    dom::Throw(cx, rv, nsDependentCString(format));
+}
+
+namespace xpc {
+
+bool
+Throw(JSContext* cx, nsresult rv)
+{
+    XPCThrower::Throw(rv, cx);
+    return false;
+}
+
+} // namespace xpc
+
+/*
+ * If there has already been an exception thrown, see if we're throwing the
+ * same sort of exception, and if we are, don't clobber the old one. ccx
+ * should be the current call context.
+ */
+// static
+bool
+XPCThrower::CheckForPendingException(nsresult result, JSContext* cx)
+{
+    nsCOMPtr<nsIException> e = XPCJSContext::Get()->GetPendingException();
+    if (!e)
+        return false;
+    XPCJSContext::Get()->SetPendingException(nullptr);
+
+    nsresult e_result;
+    if (NS_FAILED(e->GetResult(&e_result)) || e_result != result)
+        return false;
+
+    ThrowExceptionObject(cx, e);
+    return true;
+}
+
+// static
+void
+XPCThrower::Throw(nsresult rv, XPCCallContext& ccx)
+{
+    char* sz;
+    const char* format;
+
+    if (CheckForPendingException(rv, ccx))
+        return;
+
+    if (!nsXPCException::NameAndFormatForNSResult(rv, nullptr, &format))
+        format = "";
+
+    sz = (char*) format;
+    NS_ENSURE_TRUE_VOID(sz);
+
+    if (sz && sVerbose)
+        Verbosify(ccx, &sz, false);
+
+    dom::Throw(ccx, rv, nsDependentCString(sz));
+
+    if (sz && sz != format)
+        JS_smprintf_free(sz);
+}
+
+
+// static
+void
+XPCThrower::ThrowBadResult(nsresult rv, nsresult result, XPCCallContext& ccx)
+{
+    char* sz;
+    const char* format;
+    const char* name;
+
+    /*
+    *  If there is a pending exception when the native call returns and
+    *  it has the same error result as returned by the native call, then
+    *  the native call may be passing through an error from a previous JS
+    *  call. So we'll just throw that exception into our JS.  Note that
+    *  we don't need to worry about NS_ERROR_UNCATCHABLE_EXCEPTION,
+    *  because presumably there would be no pending exception for that
+    *  nsresult!
+    */
+
+    if (CheckForPendingException(result, ccx))
+        return;
+
+    // else...
+
+    if (!nsXPCException::NameAndFormatForNSResult(rv, nullptr, &format) || !format)
+        format = "";
+
+    if (nsXPCException::NameAndFormatForNSResult(result, &name, nullptr) && name)
+        sz = JS_smprintf("%s 0x%x (%s)", format, (unsigned) result, name);
+    else
+        sz = JS_smprintf("%s 0x%x", format, (unsigned) result);
+    NS_ENSURE_TRUE_VOID(sz);
+
+    if (sz && sVerbose)
+        Verbosify(ccx, &sz, true);
+
+    dom::Throw(ccx, result, nsDependentCString(sz));
+
+    if (sz)
+        JS_smprintf_free(sz);
+}
+
+// static
+void
+XPCThrower::ThrowBadParam(nsresult rv, unsigned paramNum, XPCCallContext& ccx)
+{
+    char* sz;
+    const char* format;
+
+    if (!nsXPCException::NameAndFormatForNSResult(rv, nullptr, &format))
+        format = "";
+
+    sz = JS_smprintf("%s arg %d", format, paramNum);
+    NS_ENSURE_TRUE_VOID(sz);
+
+    if (sz && sVerbose)
+        Verbosify(ccx, &sz, true);
+
+    dom::Throw(ccx, rv, nsDependentCString(sz));
+
+    if (sz)
+        JS_smprintf_free(sz);
+}
+
+
+// static
+void
+XPCThrower::Verbosify(XPCCallContext& ccx,
+                      char** psz, bool own)
+{
+    char* sz = nullptr;
+
+    if (ccx.HasInterfaceAndMember()) {
+        XPCNativeInterface* iface = ccx.GetInterface();
+        jsid id = ccx.GetMember()->GetName();
+        JSAutoByteString bytes;
+        const char* name = JSID_IS_VOID(id) ? "Unknown" : bytes.encodeLatin1(ccx, JSID_TO_STRING(id));
+        if (!name) {
+            name = "";
+        }
+        sz = JS_smprintf("%s [%s.%s]", *psz, iface->GetNameString(), name);
+    }
+
+    if (sz) {
+        if (own)
+            JS_smprintf_free(*psz);
+        *psz = sz;
+    }
+}
diff --git a/js/xpconnect/src/XPCVariant.cpp b/js/xpconnect/src/XPCVariant.cpp
new file mode 100644
index 000000000..a3d2b88c5
--- /dev/null
+++ b/js/xpconnect/src/XPCVariant.cpp
@@ -0,0 +1,800 @@
+/* -*- 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/. */
+
+/* nsIVariant implementation for xpconnect. */
+
+#include "mozilla/Range.h"
+
+#include "xpcprivate.h"
+
+#include "jsfriendapi.h"
+#include "jsprf.h"
+#include "jswrapper.h"
+
+using namespace JS;
+using namespace mozilla;
+
+NS_IMPL_CLASSINFO(XPCVariant, nullptr, 0, XPCVARIANT_CID)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XPCVariant)
+  NS_INTERFACE_MAP_ENTRY(XPCVariant)
+  NS_INTERFACE_MAP_ENTRY(nsIVariant)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+  NS_IMPL_QUERY_CLASSINFO(XPCVariant)
+NS_INTERFACE_MAP_END
+NS_IMPL_CI_INTERFACE_GETTER(XPCVariant, XPCVariant, nsIVariant)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(XPCVariant)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(XPCVariant)
+
+XPCVariant::XPCVariant(JSContext* cx, const Value& aJSVal)
+    : mJSVal(aJSVal), mCCGeneration(0)
+{
+    if (!mJSVal.isPrimitive()) {
+        // XXXbholley - The innerization here was from bug 638026. Blake says
+        // the basic problem was that we were storing the C++ inner but the JS
+        // outer, which meant that, after navigation, the JS inner could be
+        // collected, which would cause us to try to recreate the JS inner at
+        // some later point after teardown, which would crash. This is shouldn't
+        // be a problem anymore because SetParentToWindow will do the right
+        // thing, but I'm saving the cleanup here for another day. Blake thinks
+        // that we should just not store the WN if we're creating a variant for
+        // an outer window.
+        JSObject* obj = js::ToWindowIfWindowProxy(&mJSVal.toObject());
+        mJSVal = JS::ObjectValue(*obj);
+
+        JSObject* unwrapped = js::CheckedUnwrap(obj, /* stopAtWindowProxy = */ false);
+        mReturnRawObject = !(unwrapped && IS_WN_REFLECTOR(unwrapped));
+    } else
+        mReturnRawObject = false;
+}
+
+XPCTraceableVariant::~XPCTraceableVariant()
+{
+    Value val = GetJSValPreserveColor();
+
+    MOZ_ASSERT(val.isGCThing(), "Must be traceable or unlinked");
+
+    mData.Cleanup();
+
+    if (!val.isNull())
+        RemoveFromRootSet();
+}
+
+void XPCTraceableVariant::TraceJS(JSTracer* trc)
+{
+    MOZ_ASSERT(GetJSValPreserveColor().isMarkable());
+    JS::TraceEdge(trc, &mJSVal, "XPCTraceableVariant::mJSVal");
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(XPCVariant)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(XPCVariant)
+    JS::Value val = tmp->GetJSValPreserveColor();
+    if (val.isObject()) {
+        NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mJSVal");
+        cb.NoteJSChild(JS::GCCellPtr(val));
+    }
+
+    tmp->mData.Traverse(cb);
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(XPCVariant)
+    JS::Value val = tmp->GetJSValPreserveColor();
+
+    tmp->mData.Cleanup();
+
+    if (val.isMarkable()) {
+        XPCTraceableVariant* v = static_cast<XPCTraceableVariant*>(tmp);
+        v->RemoveFromRootSet();
+    }
+    tmp->mJSVal = JS::NullValue();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+// static
+already_AddRefed<XPCVariant>
+XPCVariant::newVariant(JSContext* cx, const Value& aJSVal)
+{
+    RefPtr<XPCVariant> variant;
+
+    if (!aJSVal.isMarkable())
+        variant = new XPCVariant(cx, aJSVal);
+    else
+        variant = new XPCTraceableVariant(cx, aJSVal);
+
+    if (!variant->InitializeData(cx))
+        return nullptr;
+
+    return variant.forget();
+}
+
+// Helper class to give us a namespace for the table based code below.
+class XPCArrayHomogenizer
+{
+private:
+    enum Type
+    {
+        tNull  = 0 ,  // null value
+        tInt       ,  // Integer
+        tDbl       ,  // Double
+        tBool      ,  // Boolean
+        tStr       ,  // String
+        tID        ,  // ID
+        tArr       ,  // Array
+        tISup      ,  // nsISupports (really just a plain JSObject)
+        tUnk       ,  // Unknown. Used only for initial state.
+
+        tTypeCount ,  // Just a count for table dimensioning.
+
+        tVar       ,  // nsVariant - last ditch if no other common type found.
+        tErr          // No valid state or type has this value.
+    };
+
+    // Table has tUnk as a state (column) but not as a type (row).
+    static const Type StateTable[tTypeCount][tTypeCount-1];
+
+public:
+    static bool GetTypeForArray(JSContext* cx, HandleObject array,
+                                uint32_t length,
+                                nsXPTType* resultType, nsID* resultID);
+};
+
+
+// Current state is the column down the side.
+// Current type is the row along the top.
+// New state is in the box at the intersection.
+
+const XPCArrayHomogenizer::Type
+XPCArrayHomogenizer::StateTable[tTypeCount][tTypeCount-1] = {
+/*          tNull,tInt ,tDbl ,tBool,tStr ,tID  ,tArr ,tISup */
+/* tNull */{tNull,tVar ,tVar ,tVar ,tStr ,tID  ,tVar ,tISup },
+/* tInt  */{tVar ,tInt ,tDbl ,tVar ,tVar ,tVar ,tVar ,tVar  },
+/* tDbl  */{tVar ,tDbl ,tDbl ,tVar ,tVar ,tVar ,tVar ,tVar  },
+/* tBool */{tVar ,tVar ,tVar ,tBool,tVar ,tVar ,tVar ,tVar  },
+/* tStr  */{tStr ,tVar ,tVar ,tVar ,tStr ,tVar ,tVar ,tVar  },
+/* tID   */{tID  ,tVar ,tVar ,tVar ,tVar ,tID  ,tVar ,tVar  },
+/* tArr  */{tErr ,tErr ,tErr ,tErr ,tErr ,tErr ,tErr ,tErr  },
+/* tISup */{tISup,tVar ,tVar ,tVar ,tVar ,tVar ,tVar ,tISup },
+/* tUnk  */{tNull,tInt ,tDbl ,tBool,tStr ,tID  ,tVar ,tISup }};
+
+// static
+bool
+XPCArrayHomogenizer::GetTypeForArray(JSContext* cx, HandleObject array,
+                                     uint32_t length,
+                                     nsXPTType* resultType, nsID* resultID)
+{
+    Type state = tUnk;
+    Type type;
+
+    RootedValue val(cx);
+    RootedObject jsobj(cx);
+    for (uint32_t i = 0; i < length; i++) {
+        if (!JS_GetElement(cx, array, i, &val))
+            return false;
+
+        if (val.isInt32()) {
+            type = tInt;
+        } else if (val.isDouble()) {
+            type = tDbl;
+        } else if (val.isBoolean()) {
+            type = tBool;
+        } else if (val.isUndefined() || val.isSymbol()) {
+            state = tVar;
+            break;
+        } else if (val.isNull()) {
+            type = tNull;
+        } else if (val.isString()) {
+            type = tStr;
+        } else {
+            MOZ_ASSERT(val.isObject(), "invalid type of jsval!");
+            jsobj = &val.toObject();
+
+            bool isArray;
+            if (!JS_IsArrayObject(cx, jsobj, &isArray))
+                return false;
+
+            if (isArray)
+                type = tArr;
+            else if (xpc_JSObjectIsID(cx, jsobj))
+                type = tID;
+            else
+                type = tISup;
+        }
+
+        MOZ_ASSERT(state != tErr, "bad state table!");
+        MOZ_ASSERT(type  != tErr, "bad type!");
+        MOZ_ASSERT(type  != tVar, "bad type!");
+        MOZ_ASSERT(type  != tUnk, "bad type!");
+
+        state = StateTable[state][type];
+
+        MOZ_ASSERT(state != tErr, "bad state table!");
+        MOZ_ASSERT(state != tUnk, "bad state table!");
+
+        if (state == tVar)
+            break;
+    }
+
+    switch (state) {
+        case tInt :
+            *resultType = nsXPTType((uint8_t)TD_INT32);
+            break;
+        case tDbl :
+            *resultType = nsXPTType((uint8_t)TD_DOUBLE);
+            break;
+        case tBool:
+            *resultType = nsXPTType((uint8_t)TD_BOOL);
+            break;
+        case tStr :
+            *resultType = nsXPTType((uint8_t)TD_PWSTRING);
+            break;
+        case tID  :
+            *resultType = nsXPTType((uint8_t)TD_PNSIID);
+            break;
+        case tISup:
+            *resultType = nsXPTType((uint8_t)TD_INTERFACE_IS_TYPE);
+            *resultID = NS_GET_IID(nsISupports);
+            break;
+        case tNull:
+            // FALL THROUGH
+        case tVar :
+            *resultType = nsXPTType((uint8_t)TD_INTERFACE_IS_TYPE);
+            *resultID = NS_GET_IID(nsIVariant);
+            break;
+        case tArr :
+            // FALL THROUGH
+        case tUnk :
+            // FALL THROUGH
+        case tErr :
+            // FALL THROUGH
+        default:
+            NS_ERROR("bad state");
+            return false;
+    }
+    return true;
+}
+
+bool XPCVariant::InitializeData(JSContext* cx)
+{
+    JS_CHECK_RECURSION(cx, return false);
+
+    RootedValue val(cx, GetJSVal());
+
+    if (val.isInt32()) {
+        mData.SetFromInt32(val.toInt32());
+        return true;
+    }
+    if (val.isDouble()) {
+        mData.SetFromDouble(val.toDouble());
+        return true;
+    }
+    if (val.isBoolean()) {
+        mData.SetFromBool(val.toBoolean());
+        return true;
+    }
+    // We can't represent symbol on C++ side, so pretend it is void.
+    if (val.isUndefined() || val.isSymbol()) {
+        mData.SetToVoid();
+        return true;
+    }
+    if (val.isNull()) {
+        mData.SetToEmpty();
+        return true;
+    }
+    if (val.isString()) {
+        JSString* str = val.toString();
+        if (!str)
+            return false;
+
+        MOZ_ASSERT(mData.GetType() == nsIDataType::VTYPE_EMPTY,
+                   "Why do we already have data?");
+
+        size_t length = JS_GetStringLength(str);
+        mData.AllocateWStringWithSize(length);
+
+        mozilla::Range<char16_t> destChars(mData.u.wstr.mWStringValue, length);
+        if (!JS_CopyStringChars(cx, destChars, str))
+            return false;
+
+        MOZ_ASSERT(mData.u.wstr.mWStringValue[length] == '\0');
+        return true;
+    }
+
+    // leaving only JSObject...
+    MOZ_ASSERT(val.isObject(), "invalid type of jsval!");
+
+    RootedObject jsobj(cx, &val.toObject());
+
+    // Let's see if it is a xpcJSID.
+
+    const nsID* id = xpc_JSObjectToID(cx, jsobj);
+    if (id) {
+        mData.SetFromID(*id);
+        return true;
+    }
+
+    // Let's see if it is a js array object.
+
+    uint32_t len;
+
+    bool isArray;
+    if (!JS_IsArrayObject(cx, jsobj, &isArray) ||
+        (isArray && !JS_GetArrayLength(cx, jsobj, &len)))
+    {
+        return false;
+    }
+
+    if (isArray) {
+        if (!len) {
+            // Zero length array
+            mData.SetToEmptyArray();
+            return true;
+        }
+
+        nsXPTType type;
+        nsID id;
+
+        if (!XPCArrayHomogenizer::GetTypeForArray(cx, jsobj, len, &type, &id))
+            return false;
+
+        if (!XPCConvert::JSArray2Native(&mData.u.array.mArrayValue,
+                                        val, len, type, &id, nullptr))
+            return false;
+
+        mData.mType = nsIDataType::VTYPE_ARRAY;
+        if (type.IsInterfacePointer())
+            mData.u.array.mArrayInterfaceID = id;
+        mData.u.array.mArrayCount = len;
+        mData.u.array.mArrayType = type.TagPart();
+
+        return true;
+    }
+
+    // XXX This could be smarter and pick some more interesting iface.
+
+    nsXPConnect*  xpc = nsXPConnect::XPConnect();
+    nsCOMPtr<nsISupports> wrapper;
+    const nsIID& iid = NS_GET_IID(nsISupports);
+
+    if (NS_FAILED(xpc->WrapJS(cx, jsobj, iid, getter_AddRefs(wrapper)))) {
+        return false;
+    }
+
+    mData.SetFromInterface(iid, wrapper);
+    return true;
+}
+
+NS_IMETHODIMP
+XPCVariant::GetAsJSVal(MutableHandleValue result)
+{
+  result.set(GetJSVal());
+  return NS_OK;
+}
+
+// static
+bool
+XPCVariant::VariantDataToJS(nsIVariant* variant,
+                            nsresult* pErr, MutableHandleValue pJSVal)
+{
+    // Get the type early because we might need to spoof it below.
+    uint16_t type;
+    if (NS_FAILED(variant->GetDataType(&type)))
+        return false;
+
+    AutoJSContext cx;
+    RootedValue realVal(cx);
+    nsresult rv = variant->GetAsJSVal(&realVal);
+
+    if (NS_SUCCEEDED(rv) &&
+        (realVal.isPrimitive() ||
+         type == nsIDataType::VTYPE_ARRAY ||
+         type == nsIDataType::VTYPE_EMPTY_ARRAY ||
+         type == nsIDataType::VTYPE_ID)) {
+        if (!JS_WrapValue(cx, &realVal))
+            return false;
+        pJSVal.set(realVal);
+        return true;
+    }
+
+    nsCOMPtr<XPCVariant> xpcvariant = do_QueryInterface(variant);
+    if (xpcvariant && xpcvariant->mReturnRawObject) {
+        MOZ_ASSERT(type == nsIDataType::VTYPE_INTERFACE ||
+                   type == nsIDataType::VTYPE_INTERFACE_IS,
+                   "Weird variant");
+
+        if (!JS_WrapValue(cx, &realVal))
+            return false;
+        pJSVal.set(realVal);
+        return true;
+    }
+
+    // else, it's an object and we really need to double wrap it if we've
+    // already decided that its 'natural' type is as some sort of interface.
+
+    // We just fall through to the code below and let it do what it does.
+
+    // The nsIVariant is not a XPCVariant (or we act like it isn't).
+    // So we extract the data and do the Right Thing.
+
+    // We ASSUME that the variant implementation can do these conversions...
+
+    nsID iid;
+
+    switch (type) {
+        case nsIDataType::VTYPE_INT8:
+        case nsIDataType::VTYPE_INT16:
+        case nsIDataType::VTYPE_INT32:
+        case nsIDataType::VTYPE_INT64:
+        case nsIDataType::VTYPE_UINT8:
+        case nsIDataType::VTYPE_UINT16:
+        case nsIDataType::VTYPE_UINT32:
+        case nsIDataType::VTYPE_UINT64:
+        case nsIDataType::VTYPE_FLOAT:
+        case nsIDataType::VTYPE_DOUBLE:
+        {
+            double d;
+            if (NS_FAILED(variant->GetAsDouble(&d)))
+                return false;
+            pJSVal.setNumber(d);
+            return true;
+        }
+        case nsIDataType::VTYPE_BOOL:
+        {
+            bool b;
+            if (NS_FAILED(variant->GetAsBool(&b)))
+                return false;
+            pJSVal.setBoolean(b);
+            return true;
+        }
+        case nsIDataType::VTYPE_CHAR:
+        {
+            char c;
+            if (NS_FAILED(variant->GetAsChar(&c)))
+                return false;
+            return XPCConvert::NativeData2JS(pJSVal, (const void*)&c, TD_CHAR, &iid, pErr);
+        }
+        case nsIDataType::VTYPE_WCHAR:
+        {
+            char16_t wc;
+            if (NS_FAILED(variant->GetAsWChar(&wc)))
+                return false;
+            return XPCConvert::NativeData2JS(pJSVal, (const void*)&wc, TD_WCHAR, &iid, pErr);
+        }
+        case nsIDataType::VTYPE_ID:
+        {
+            if (NS_FAILED(variant->GetAsID(&iid)))
+                return false;
+            nsID* v = &iid;
+            return XPCConvert::NativeData2JS(pJSVal, (const void*)&v, TD_PNSIID, &iid, pErr);
+        }
+        case nsIDataType::VTYPE_ASTRING:
+        {
+            nsAutoString astring;
+            if (NS_FAILED(variant->GetAsAString(astring)))
+                return false;
+            nsAutoString* v = &astring;
+            return XPCConvert::NativeData2JS(pJSVal, (const void*)&v, TD_ASTRING, &iid, pErr);
+        }
+        case nsIDataType::VTYPE_DOMSTRING:
+        {
+            nsAutoString astring;
+            if (NS_FAILED(variant->GetAsAString(astring)))
+                return false;
+            nsAutoString* v = &astring;
+            return XPCConvert::NativeData2JS(pJSVal, (const void*)&v,
+                                             TD_DOMSTRING, &iid, pErr);
+        }
+        case nsIDataType::VTYPE_CSTRING:
+        {
+            nsAutoCString cString;
+            if (NS_FAILED(variant->GetAsACString(cString)))
+                return false;
+            nsAutoCString* v = &cString;
+            return XPCConvert::NativeData2JS(pJSVal, (const void*)&v,
+                                             TD_CSTRING, &iid, pErr);
+        }
+        case nsIDataType::VTYPE_UTF8STRING:
+        {
+            nsUTF8String utf8String;
+            if (NS_FAILED(variant->GetAsAUTF8String(utf8String)))
+                return false;
+            nsUTF8String* v = &utf8String;
+            return XPCConvert::NativeData2JS(pJSVal, (const void*)&v,
+                                             TD_UTF8STRING, &iid, pErr);
+        }
+        case nsIDataType::VTYPE_CHAR_STR:
+        {
+            char* pc;
+            if (NS_FAILED(variant->GetAsString(&pc)))
+                return false;
+            bool success = XPCConvert::NativeData2JS(pJSVal, (const void*)&pc,
+                                                     TD_PSTRING, &iid, pErr);
+            free(pc);
+            return success;
+        }
+        case nsIDataType::VTYPE_STRING_SIZE_IS:
+        {
+            char* pc;
+            uint32_t size;
+            if (NS_FAILED(variant->GetAsStringWithSize(&size, &pc)))
+                return false;
+            bool success = XPCConvert::NativeStringWithSize2JS(pJSVal, (const void*)&pc,
+                                                               TD_PSTRING_SIZE_IS, size, pErr);
+            free(pc);
+            return success;
+        }
+        case nsIDataType::VTYPE_WCHAR_STR:
+        {
+            char16_t* pwc;
+            if (NS_FAILED(variant->GetAsWString(&pwc)))
+                return false;
+            bool success = XPCConvert::NativeData2JS(pJSVal, (const void*)&pwc,
+                                                     TD_PSTRING, &iid, pErr);
+            free(pwc);
+            return success;
+        }
+        case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+        {
+            char16_t* pwc;
+            uint32_t size;
+            if (NS_FAILED(variant->GetAsWStringWithSize(&size, &pwc)))
+                return false;
+            bool success = XPCConvert::NativeStringWithSize2JS(pJSVal, (const void*)&pwc,
+                                                               TD_PWSTRING_SIZE_IS, size, pErr);
+            free(pwc);
+            return success;
+        }
+        case nsIDataType::VTYPE_INTERFACE:
+        case nsIDataType::VTYPE_INTERFACE_IS:
+        {
+            nsISupports* pi;
+            nsID* piid;
+            if (NS_FAILED(variant->GetAsInterface(&piid, (void**)&pi)))
+                return false;
+
+            iid = *piid;
+            free((char*)piid);
+
+            bool success = XPCConvert::NativeData2JS(pJSVal, (const void*)&pi,
+                                                     TD_INTERFACE_IS_TYPE, &iid, pErr);
+            if (pi)
+                pi->Release();
+            return success;
+        }
+        case nsIDataType::VTYPE_ARRAY:
+        {
+            nsDiscriminatedUnion du;
+            nsresult rv;
+
+            rv = variant->GetAsArray(&du.u.array.mArrayType,
+                                     &du.u.array.mArrayInterfaceID,
+                                     &du.u.array.mArrayCount,
+                                     &du.u.array.mArrayValue);
+            if (NS_FAILED(rv))
+                return false;
+
+            // must exit via VARIANT_DONE from here on...
+            du.mType = nsIDataType::VTYPE_ARRAY;
+
+            nsXPTType conversionType;
+            uint16_t elementType = du.u.array.mArrayType;
+            const nsID* pid = nullptr;
+
+            switch (elementType) {
+                case nsIDataType::VTYPE_INT8:
+                case nsIDataType::VTYPE_INT16:
+                case nsIDataType::VTYPE_INT32:
+                case nsIDataType::VTYPE_INT64:
+                case nsIDataType::VTYPE_UINT8:
+                case nsIDataType::VTYPE_UINT16:
+                case nsIDataType::VTYPE_UINT32:
+                case nsIDataType::VTYPE_UINT64:
+                case nsIDataType::VTYPE_FLOAT:
+                case nsIDataType::VTYPE_DOUBLE:
+                case nsIDataType::VTYPE_BOOL:
+                case nsIDataType::VTYPE_CHAR:
+                case nsIDataType::VTYPE_WCHAR:
+                    conversionType = nsXPTType((uint8_t)elementType);
+                    break;
+
+                case nsIDataType::VTYPE_ID:
+                case nsIDataType::VTYPE_CHAR_STR:
+                case nsIDataType::VTYPE_WCHAR_STR:
+                    conversionType = nsXPTType((uint8_t)elementType);
+                    break;
+
+                case nsIDataType::VTYPE_INTERFACE:
+                    pid = &NS_GET_IID(nsISupports);
+                    conversionType = nsXPTType((uint8_t)elementType);
+                    break;
+
+                case nsIDataType::VTYPE_INTERFACE_IS:
+                    pid = &du.u.array.mArrayInterfaceID;
+                    conversionType = nsXPTType((uint8_t)elementType);
+                    break;
+
+                // The rest are illegal.
+                case nsIDataType::VTYPE_VOID:
+                case nsIDataType::VTYPE_ASTRING:
+                case nsIDataType::VTYPE_DOMSTRING:
+                case nsIDataType::VTYPE_CSTRING:
+                case nsIDataType::VTYPE_UTF8STRING:
+                case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+                case nsIDataType::VTYPE_STRING_SIZE_IS:
+                case nsIDataType::VTYPE_ARRAY:
+                case nsIDataType::VTYPE_EMPTY_ARRAY:
+                case nsIDataType::VTYPE_EMPTY:
+                default:
+                    NS_ERROR("bad type in array!");
+                    return false;
+            }
+
+            bool success =
+                XPCConvert::NativeArray2JS(pJSVal,
+                                           (const void**)&du.u.array.mArrayValue,
+                                           conversionType, pid,
+                                           du.u.array.mArrayCount, pErr);
+
+            return success;
+        }
+        case nsIDataType::VTYPE_EMPTY_ARRAY:
+        {
+            JSObject* array = JS_NewArrayObject(cx, 0);
+            if (!array)
+                return false;
+            pJSVal.setObject(*array);
+            return true;
+        }
+        case nsIDataType::VTYPE_VOID:
+            pJSVal.setUndefined();
+            return true;
+        case nsIDataType::VTYPE_EMPTY:
+            pJSVal.setNull();
+            return true;
+        default:
+            NS_ERROR("bad type in variant!");
+            return false;
+    }
+}
+
+/***************************************************************************/
+/***************************************************************************/
+// XXX These default implementations need to be improved to allow for
+// some more interesting conversions.
+
+
+NS_IMETHODIMP XPCVariant::GetDataType(uint16_t* aDataType)
+{
+    *aDataType = mData.GetType();
+    return NS_OK;
+}
+
+NS_IMETHODIMP XPCVariant::GetAsInt8(uint8_t* _retval)
+{
+    return mData.ConvertToInt8(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsInt16(int16_t* _retval)
+{
+    return mData.ConvertToInt16(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsInt32(int32_t* _retval)
+{
+    return mData.ConvertToInt32(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsInt64(int64_t* _retval)
+{
+    return mData.ConvertToInt64(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsUint8(uint8_t* _retval)
+{
+    return mData.ConvertToUint8(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsUint16(uint16_t* _retval)
+{
+    return mData.ConvertToUint16(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsUint32(uint32_t* _retval)
+{
+    return mData.ConvertToUint32(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsUint64(uint64_t* _retval)
+{
+    return mData.ConvertToUint64(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsFloat(float* _retval)
+{
+    return mData.ConvertToFloat(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsDouble(double* _retval)
+{
+    return mData.ConvertToDouble(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsBool(bool* _retval)
+{
+    return mData.ConvertToBool(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsChar(char* _retval)
+{
+    return mData.ConvertToChar(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsWChar(char16_t* _retval)
+{
+    return mData.ConvertToWChar(_retval);
+}
+
+NS_IMETHODIMP_(nsresult) XPCVariant::GetAsID(nsID* retval)
+{
+    return mData.ConvertToID(retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsAString(nsAString & _retval)
+{
+    return mData.ConvertToAString(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsDOMString(nsAString & _retval)
+{
+    // A DOMString maps to an AString internally, so we can re-use
+    // ConvertToAString here.
+    return mData.ConvertToAString(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsACString(nsACString & _retval)
+{
+    return mData.ConvertToACString(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsAUTF8String(nsAUTF8String & _retval)
+{
+    return mData.ConvertToAUTF8String(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsString(char** _retval)
+{
+    return mData.ConvertToString(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsWString(char16_t** _retval)
+{
+    return mData.ConvertToWString(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsISupports(nsISupports** _retval)
+{
+    return mData.ConvertToISupports(_retval);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsInterface(nsIID** iid, void** iface)
+{
+    return mData.ConvertToInterface(iid, iface);
+}
+
+
+NS_IMETHODIMP_(nsresult) XPCVariant::GetAsArray(uint16_t* type, nsIID* iid, uint32_t* count, void * *ptr)
+{
+    return mData.ConvertToArray(type, iid, count, ptr);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsStringWithSize(uint32_t* size, char** str)
+{
+    return mData.ConvertToStringWithSize(size, str);
+}
+
+NS_IMETHODIMP XPCVariant::GetAsWStringWithSize(uint32_t* size, char16_t** str)
+{
+    return mData.ConvertToWStringWithSize(size, str);
+}
diff --git a/js/xpconnect/src/XPCWrappedJS.cpp b/js/xpconnect/src/XPCWrappedJS.cpp
new file mode 100644
index 000000000..ebcfe6590
--- /dev/null
+++ b/js/xpconnect/src/XPCWrappedJS.cpp
@@ -0,0 +1,731 @@
+/* -*- 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/. */
+
+/* Class that wraps JS objects to appear as XPCOM objects. */
+
+#include "xpcprivate.h"
+#include "jsprf.h"
+#include "mozilla/DeferredFinalize.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
+#include "nsCCUncollectableMarker.h"
+#include "nsContentUtils.h"
+#include "nsThreadUtils.h"
+
+using namespace mozilla;
+
+// NOTE: much of the fancy footwork is done in xpcstubs.cpp
+
+
+// nsXPCWrappedJS lifetime.
+//
+// An nsXPCWrappedJS is either rooting its JS object or is subject to finalization.
+// The subject-to-finalization state lets wrappers support
+// nsSupportsWeakReference in the case where the underlying JS object
+// is strongly owned, but the wrapper itself is only weakly owned.
+//
+// A wrapper is rooting its JS object whenever its refcount is greater than 1. In
+// this state, root wrappers are always added to the cycle collector graph. The
+// wrapper keeps around an extra refcount, added in the constructor, to support
+// the possibility of an eventual transition to the subject-to-finalization state.
+// This extra refcount is ignored by the cycle collector, which traverses the "self"
+// edge for this refcount.
+//
+// When the refcount of a rooting wrapper drops to 1, if there is no weak reference
+// to the wrapper (which can only happen for the root wrapper), it is immediately
+// Destroy()'d. Otherwise, it becomes subject to finalization.
+//
+// When a wrapper is subject to finalization, the wrapper has a refcount of 1. It is
+// now owned exclusively by its JS object. Either a weak reference will be turned into
+// a strong ref which will bring its refcount up to 2 and change the wrapper back to
+// the rooting state, or it will stay alive until the JS object dies. If the JS object
+// dies, then when XPCJSContext::FinalizeCallback calls FindDyingJSObjects
+// it will find the wrapper and call Release() in it, destroying the wrapper.
+// Otherwise, the wrapper will stay alive, even if it no longer has a weak reference
+// to it.
+//
+// When the wrapper is subject to finalization, it is kept alive by an implicit reference
+// from the JS object which is invisible to the cycle collector, so the cycle collector
+// does not traverse any children of wrappers that are subject to finalization. This will
+// result in a leak if a wrapper in the non-rooting state has an aggregated native that
+// keeps alive the wrapper's JS object.  See bug 947049.
+
+
+// If traversing wrappedJS wouldn't release it, nor cause any other objects to be
+// added to the graph, there is no need to add it to the graph at all.
+bool
+nsXPCWrappedJS::CanSkip()
+{
+    if (!nsCCUncollectableMarker::sGeneration)
+        return false;
+
+    if (IsSubjectToFinalization())
+        return true;
+
+    // If this wrapper holds a gray object, need to trace it.
+    JSObject* obj = GetJSObjectPreserveColor();
+    if (obj && JS::ObjectIsMarkedGray(obj))
+        return false;
+
+    // For non-root wrappers, check if the root wrapper will be
+    // added to the CC graph.
+    if (!IsRootWrapper()) {
+        // mRoot points to null after unlinking.
+        NS_ENSURE_TRUE(mRoot, false);
+        return mRoot->CanSkip();
+    }
+
+    // For the root wrapper, check if there is an aggregated
+    // native object that will be added to the CC graph.
+    if (!IsAggregatedToNative())
+        return true;
+
+    nsISupports* agg = GetAggregatedNativeObject();
+    nsXPCOMCycleCollectionParticipant* cp = nullptr;
+    CallQueryInterface(agg, &cp);
+    nsISupports* canonical = nullptr;
+    agg->QueryInterface(NS_GET_IID(nsCycleCollectionISupports),
+                        reinterpret_cast<void**>(&canonical));
+    return cp && canonical && cp->CanSkipThis(canonical);
+}
+
+NS_IMETHODIMP
+NS_CYCLE_COLLECTION_CLASSNAME(nsXPCWrappedJS)::Traverse
+   (void* p, nsCycleCollectionTraversalCallback& cb)
+{
+    nsISupports* s = static_cast<nsISupports*>(p);
+    MOZ_ASSERT(CheckForRightISupports(s), "not the nsISupports pointer we expect");
+    nsXPCWrappedJS* tmp = Downcast(s);
+
+    nsrefcnt refcnt = tmp->mRefCnt.get();
+    if (cb.WantDebugInfo()) {
+        char name[72];
+        if (tmp->GetClass())
+            SprintfLiteral(name, "nsXPCWrappedJS (%s)", tmp->GetClass()->GetInterfaceName());
+        else
+            SprintfLiteral(name, "nsXPCWrappedJS");
+        cb.DescribeRefCountedNode(refcnt, name);
+    } else {
+        NS_IMPL_CYCLE_COLLECTION_DESCRIBE(nsXPCWrappedJS, refcnt)
+    }
+
+    // A wrapper that is subject to finalization will only die when its JS object dies.
+    if (tmp->IsSubjectToFinalization())
+        return NS_OK;
+
+    // Don't let the extra reference for nsSupportsWeakReference keep a wrapper that is
+    // not subject to finalization alive.
+    NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "self");
+    cb.NoteXPCOMChild(s);
+
+    if (tmp->IsValid()) {
+        MOZ_ASSERT(refcnt > 1);
+        NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mJSObj");
+        cb.NoteJSChild(JS::GCCellPtr(tmp->GetJSObjectPreserveColor()));
+    }
+
+    if (tmp->IsRootWrapper()) {
+        NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "aggregated native");
+        cb.NoteXPCOMChild(tmp->GetAggregatedNativeObject());
+    } else {
+        NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "root");
+        cb.NoteXPCOMChild(ToSupports(tmp->GetRootWrapper()));
+    }
+
+    return NS_OK;
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsXPCWrappedJS)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsXPCWrappedJS)
+    tmp->Unlink();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+// XPCJSContext keeps a table of WJS, so we can remove them from
+// the purple buffer in between CCs.
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsXPCWrappedJS)
+    return true;
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsXPCWrappedJS)
+    return tmp->CanSkip();
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsXPCWrappedJS)
+    return tmp->CanSkip();
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
+
+NS_IMETHODIMP
+nsXPCWrappedJS::AggregatedQueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+    MOZ_ASSERT(IsAggregatedToNative(), "bad AggregatedQueryInterface call");
+    *aInstancePtr = nullptr;
+
+    if (!IsValid())
+        return NS_ERROR_UNEXPECTED;
+
+    // Put this here rather that in DelegatedQueryInterface because it needs
+    // to be in QueryInterface before the possible delegation to 'outer', but
+    // we don't want to do this check twice in one call in the normal case:
+    // once in QueryInterface and once in DelegatedQueryInterface.
+    if (aIID.Equals(NS_GET_IID(nsIXPConnectWrappedJS))) {
+        NS_ADDREF(this);
+        *aInstancePtr = (void*) static_cast<nsIXPConnectWrappedJS*>(this);
+        return NS_OK;
+    }
+
+    return mClass->DelegatedQueryInterface(this, aIID, aInstancePtr);
+}
+
+NS_IMETHODIMP
+nsXPCWrappedJS::QueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+    if (nullptr == aInstancePtr) {
+        NS_PRECONDITION(false, "null pointer");
+        return NS_ERROR_NULL_POINTER;
+    }
+
+    *aInstancePtr = nullptr;
+
+    if ( aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant)) ) {
+        *aInstancePtr = NS_CYCLE_COLLECTION_PARTICIPANT(nsXPCWrappedJS);
+        return NS_OK;
+    }
+
+    if (aIID.Equals(NS_GET_IID(nsCycleCollectionISupports))) {
+        *aInstancePtr =
+            NS_CYCLE_COLLECTION_CLASSNAME(nsXPCWrappedJS)::Upcast(this);
+        return NS_OK;
+    }
+
+    if (!IsValid())
+        return NS_ERROR_UNEXPECTED;
+
+    if (aIID.Equals(NS_GET_IID(nsIXPConnectWrappedJSUnmarkGray))) {
+        *aInstancePtr = nullptr;
+
+        mJSObj.exposeToActiveJS();
+
+        // Just return some error value since one isn't supposed to use
+        // nsIXPConnectWrappedJSUnmarkGray objects for anything.
+        return NS_ERROR_FAILURE;
+    }
+
+    // Always check for this first so that our 'outer' can get this interface
+    // from us without recurring into a call to the outer's QI!
+    if (aIID.Equals(NS_GET_IID(nsIXPConnectWrappedJS))) {
+        NS_ADDREF(this);
+        *aInstancePtr = (void*) static_cast<nsIXPConnectWrappedJS*>(this);
+        return NS_OK;
+    }
+
+    nsISupports* outer = GetAggregatedNativeObject();
+    if (outer)
+        return outer->QueryInterface(aIID, aInstancePtr);
+
+    // else...
+
+    return mClass->DelegatedQueryInterface(this, aIID, aInstancePtr);
+}
+
+
+// For a description of nsXPCWrappedJS lifetime and reference counting, see
+// the comment at the top of this file.
+
+MozExternalRefCountType
+nsXPCWrappedJS::AddRef(void)
+{
+    MOZ_RELEASE_ASSERT(NS_IsMainThread(),
+                       "nsXPCWrappedJS::AddRef called off main thread");
+
+    MOZ_ASSERT(int32_t(mRefCnt) >= 0, "illegal refcnt");
+    nsISupports* base = NS_CYCLE_COLLECTION_CLASSNAME(nsXPCWrappedJS)::Upcast(this);
+    nsrefcnt cnt = mRefCnt.incr(base);
+    NS_LOG_ADDREF(this, cnt, "nsXPCWrappedJS", sizeof(*this));
+
+    if (2 == cnt && IsValid()) {
+        GetJSObject(); // Unmark gray JSObject.
+        mClass->GetContext()->AddWrappedJSRoot(this);
+    }
+
+    return cnt;
+}
+
+MozExternalRefCountType
+nsXPCWrappedJS::Release(void)
+{
+    MOZ_RELEASE_ASSERT(NS_IsMainThread(),
+                       "nsXPCWrappedJS::Release called off main thread");
+    MOZ_ASSERT(int32_t(mRefCnt) > 0, "dup release");
+    NS_ASSERT_OWNINGTHREAD(nsXPCWrappedJS);
+
+    bool shouldDelete = false;
+    nsISupports* base = NS_CYCLE_COLLECTION_CLASSNAME(nsXPCWrappedJS)::Upcast(this);
+    nsrefcnt cnt = mRefCnt.decr(base, &shouldDelete);
+    NS_LOG_RELEASE(this, cnt, "nsXPCWrappedJS");
+
+    if (0 == cnt) {
+        if (MOZ_UNLIKELY(shouldDelete)) {
+            mRefCnt.stabilizeForDeletion();
+            DeleteCycleCollectable();
+        } else {
+            mRefCnt.incr(base);
+            Destroy();
+            mRefCnt.decr(base);
+        }
+    } else if (1 == cnt) {
+        if (IsValid())
+            RemoveFromRootSet();
+
+        // If we are not a root wrapper being used from a weak reference,
+        // then the extra ref is not needed and we can let outselves be
+        // deleted.
+        if (!HasWeakReferences())
+            return Release();
+
+        MOZ_ASSERT(IsRootWrapper(), "Only root wrappers should have weak references");
+    }
+    return cnt;
+}
+
+NS_IMETHODIMP_(void)
+nsXPCWrappedJS::DeleteCycleCollectable(void)
+{
+    delete this;
+}
+
+void
+nsXPCWrappedJS::TraceJS(JSTracer* trc)
+{
+    MOZ_ASSERT(mRefCnt >= 2 && IsValid(), "must be strongly referenced");
+    JS::TraceEdge(trc, &mJSObj, "nsXPCWrappedJS::mJSObj");
+}
+
+NS_IMETHODIMP
+nsXPCWrappedJS::GetWeakReference(nsIWeakReference** aInstancePtr)
+{
+    if (!IsRootWrapper())
+        return mRoot->GetWeakReference(aInstancePtr);
+
+    return nsSupportsWeakReference::GetWeakReference(aInstancePtr);
+}
+
+JSObject*
+nsXPCWrappedJS::GetJSObject()
+{
+    return mJSObj;
+}
+
+// static
+nsresult
+nsXPCWrappedJS::GetNewOrUsed(JS::HandleObject jsObj,
+                             REFNSIID aIID,
+                             nsXPCWrappedJS** wrapperResult)
+{
+    // Do a release-mode assert against accessing nsXPCWrappedJS off-main-thread.
+    MOZ_RELEASE_ASSERT(NS_IsMainThread(),
+                       "nsXPCWrappedJS::GetNewOrUsed called off main thread");
+
+    AutoJSContext cx;
+
+    bool allowNonScriptable = mozilla::jsipc::IsWrappedCPOW(jsObj);
+    RefPtr<nsXPCWrappedJSClass> clasp = nsXPCWrappedJSClass::GetNewOrUsed(cx, aIID,
+                                                                          allowNonScriptable);
+    if (!clasp)
+        return NS_ERROR_FAILURE;
+
+    JS::RootedObject rootJSObj(cx, clasp->GetRootJSObject(cx, jsObj));
+    if (!rootJSObj)
+        return NS_ERROR_FAILURE;
+
+    xpc::CompartmentPrivate* rootComp = xpc::CompartmentPrivate::Get(rootJSObj);
+    MOZ_ASSERT(rootComp);
+
+    // Find any existing wrapper.
+    RefPtr<nsXPCWrappedJS> root = rootComp->GetWrappedJSMap()->Find(rootJSObj);
+    MOZ_ASSERT_IF(root, !nsXPConnect::GetContextInstance()->GetMultiCompartmentWrappedJSMap()->
+                        Find(rootJSObj));
+    if (!root) {
+        root = nsXPConnect::GetContextInstance()->GetMultiCompartmentWrappedJSMap()->
+            Find(rootJSObj);
+    }
+
+    nsresult rv = NS_ERROR_FAILURE;
+    if (root) {
+        RefPtr<nsXPCWrappedJS> wrapper = root->FindOrFindInherited(aIID);
+        if (wrapper) {
+            wrapper.forget(wrapperResult);
+            return NS_OK;
+        }
+    } else if (rootJSObj != jsObj) {
+
+        // Make a new root wrapper, because there is no existing
+        // root wrapper, and the wrapper we are trying to make isn't
+        // a root.
+        RefPtr<nsXPCWrappedJSClass> rootClasp =
+            nsXPCWrappedJSClass::GetNewOrUsed(cx, NS_GET_IID(nsISupports));
+        if (!rootClasp)
+            return NS_ERROR_FAILURE;
+
+        root = new nsXPCWrappedJS(cx, rootJSObj, rootClasp, nullptr, &rv);
+        if (NS_FAILED(rv)) {
+            return rv;
+        }
+    }
+
+    RefPtr<nsXPCWrappedJS> wrapper = new nsXPCWrappedJS(cx, jsObj, clasp, root, &rv);
+    if (NS_FAILED(rv)) {
+        return rv;
+    }
+    wrapper.forget(wrapperResult);
+    return NS_OK;
+}
+
+nsXPCWrappedJS::nsXPCWrappedJS(JSContext* cx,
+                               JSObject* aJSObj,
+                               nsXPCWrappedJSClass* aClass,
+                               nsXPCWrappedJS* root,
+                               nsresult* rv)
+    : mJSObj(aJSObj),
+      mClass(aClass),
+      mRoot(root ? root : this),
+      mNext(nullptr)
+{
+    *rv = InitStub(GetClass()->GetIID());
+    // Continue even in the failure case, so that our refcounting/Destroy
+    // behavior works correctly.
+
+    // There is an extra AddRef to support weak references to wrappers
+    // that are subject to finalization. See the top of the file for more
+    // details.
+    NS_ADDREF_THIS();
+
+    if (IsRootWrapper()) {
+        MOZ_ASSERT(!IsMultiCompartment(), "mNext is always nullptr here");
+        if (!xpc::CompartmentPrivate::Get(mJSObj)->GetWrappedJSMap()->Add(cx, this)) {
+            *rv = NS_ERROR_OUT_OF_MEMORY;
+        }
+    } else {
+        NS_ADDREF(mRoot);
+        mNext = mRoot->mNext;
+        mRoot->mNext = this;
+
+        // We always start wrappers in the per-compartment table. If adding
+        // this wrapper to the chain causes it to cross compartments, we need
+        // to migrate the chain to the global table on the XPCJSContext.
+        if (mRoot->IsMultiCompartment()) {
+            xpc::CompartmentPrivate::Get(mRoot->mJSObj)->GetWrappedJSMap()->Remove(mRoot);
+            auto destMap = nsXPConnect::GetContextInstance()->GetMultiCompartmentWrappedJSMap();
+            if (!destMap->Add(cx, mRoot)) {
+                *rv = NS_ERROR_OUT_OF_MEMORY;
+            }
+        }
+    }
+}
+
+nsXPCWrappedJS::~nsXPCWrappedJS()
+{
+    Destroy();
+}
+
+void
+XPCJSContext::RemoveWrappedJS(nsXPCWrappedJS* wrapper)
+{
+    AssertInvalidWrappedJSNotInTable(wrapper);
+    if (!wrapper->IsValid())
+        return;
+
+    // It is possible for the same JS XPCOM implementation object to be wrapped
+    // with a different interface in multiple JSCompartments. In this case, the
+    // wrapper chain will contain references to multiple compartments. While we
+    // always store single-compartment chains in the per-compartment wrapped-js
+    // table, chains in the multi-compartment wrapped-js table may contain
+    // single-compartment chains, if they have ever contained a wrapper in a
+    // different compartment. Since removal requires a lookup anyway, we just do
+    // the remove on both tables unconditionally.
+    MOZ_ASSERT_IF(wrapper->IsMultiCompartment(),
+                  !xpc::CompartmentPrivate::Get(wrapper->GetJSObjectPreserveColor())->
+                      GetWrappedJSMap()->HasWrapper(wrapper));
+    GetMultiCompartmentWrappedJSMap()->Remove(wrapper);
+    xpc::CompartmentPrivate::Get(wrapper->GetJSObjectPreserveColor())->GetWrappedJSMap()->
+        Remove(wrapper);
+}
+
+#ifdef DEBUG
+static void
+NotHasWrapperAssertionCallback(JSContext* cx, void* data, JSCompartment* comp)
+{
+    auto wrapper = static_cast<nsXPCWrappedJS*>(data);
+    auto xpcComp = xpc::CompartmentPrivate::Get(comp);
+    MOZ_ASSERT_IF(xpcComp, !xpcComp->GetWrappedJSMap()->HasWrapper(wrapper));
+}
+#endif
+
+void
+XPCJSContext::AssertInvalidWrappedJSNotInTable(nsXPCWrappedJS* wrapper) const
+{
+#ifdef DEBUG
+    if (!wrapper->IsValid()) {
+        MOZ_ASSERT(!GetMultiCompartmentWrappedJSMap()->HasWrapper(wrapper));
+        if (!mGCIsRunning)
+            JS_IterateCompartments(Context(), wrapper, NotHasWrapperAssertionCallback);
+    }
+#endif
+}
+
+void
+nsXPCWrappedJS::Destroy()
+{
+    MOZ_ASSERT(1 == int32_t(mRefCnt), "should be stabilized for deletion");
+
+    if (IsRootWrapper())
+        nsXPConnect::GetContextInstance()->RemoveWrappedJS(this);
+    Unlink();
+}
+
+void
+nsXPCWrappedJS::Unlink()
+{
+    nsXPConnect::GetContextInstance()->AssertInvalidWrappedJSNotInTable(this);
+
+    if (IsValid()) {
+        XPCJSContext* cx = nsXPConnect::GetContextInstance();
+        if (cx) {
+            if (IsRootWrapper())
+                cx->RemoveWrappedJS(this);
+
+            if (mRefCnt > 1)
+                RemoveFromRootSet();
+        }
+
+        mJSObj = nullptr;
+    }
+
+    if (IsRootWrapper()) {
+        ClearWeakReferences();
+    } else if (mRoot) {
+        // unlink this wrapper
+        nsXPCWrappedJS* cur = mRoot;
+        while (1) {
+            if (cur->mNext == this) {
+                cur->mNext = mNext;
+                break;
+            }
+            cur = cur->mNext;
+            MOZ_ASSERT(cur, "failed to find wrapper in its own chain");
+        }
+
+        // Note: unlinking this wrapper may have changed us from a multi-
+        // compartment wrapper chain to a single-compartment wrapper chain. We
+        // leave the wrapper in the multi-compartment table as it is likely to
+        // need to be multi-compartment again in the future and, moreover, we
+        // cannot get a JSContext here.
+
+        // let the root go
+        NS_RELEASE(mRoot);
+    }
+
+    mClass = nullptr;
+    if (mOuter) {
+        XPCJSContext* cx = nsXPConnect::GetContextInstance();
+        if (cx->GCIsRunning()) {
+            DeferredFinalize(mOuter.forget().take());
+        } else {
+            mOuter = nullptr;
+        }
+    }
+}
+
+bool
+nsXPCWrappedJS::IsMultiCompartment() const
+{
+    MOZ_ASSERT(IsRootWrapper());
+    JSCompartment* compartment = Compartment();
+    nsXPCWrappedJS* next = mNext;
+    while (next) {
+        if (next->Compartment() != compartment)
+            return true;
+        next = next->mNext;
+    }
+    return false;
+}
+
+nsXPCWrappedJS*
+nsXPCWrappedJS::Find(REFNSIID aIID)
+{
+    if (aIID.Equals(NS_GET_IID(nsISupports)))
+        return mRoot;
+
+    for (nsXPCWrappedJS* cur = mRoot; cur; cur = cur->mNext) {
+        if (aIID.Equals(cur->GetIID()))
+            return cur;
+    }
+
+    return nullptr;
+}
+
+// check if asking for an interface that some wrapper in the chain inherits from
+nsXPCWrappedJS*
+nsXPCWrappedJS::FindInherited(REFNSIID aIID)
+{
+    MOZ_ASSERT(!aIID.Equals(NS_GET_IID(nsISupports)), "bad call sequence");
+
+    for (nsXPCWrappedJS* cur = mRoot; cur; cur = cur->mNext) {
+        bool found;
+        if (NS_SUCCEEDED(cur->GetClass()->GetInterfaceInfo()->
+                         HasAncestor(&aIID, &found)) && found)
+            return cur;
+    }
+
+    return nullptr;
+}
+
+NS_IMETHODIMP
+nsXPCWrappedJS::GetInterfaceInfo(nsIInterfaceInfo** infoResult)
+{
+    MOZ_ASSERT(GetClass(), "wrapper without class");
+    MOZ_ASSERT(GetClass()->GetInterfaceInfo(), "wrapper class without interface");
+
+    // Since failing to get this info will crash some platforms(!), we keep
+    // mClass valid at shutdown time.
+
+    nsCOMPtr<nsIInterfaceInfo> info = GetClass()->GetInterfaceInfo();
+    if (!info)
+        return NS_ERROR_UNEXPECTED;
+    info.forget(infoResult);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPCWrappedJS::CallMethod(uint16_t methodIndex,
+                           const XPTMethodDescriptor* info,
+                           nsXPTCMiniVariant* params)
+{
+    // Do a release-mode assert against accessing nsXPCWrappedJS off-main-thread.
+    MOZ_RELEASE_ASSERT(NS_IsMainThread(),
+                       "nsXPCWrappedJS::CallMethod called off main thread");
+
+    if (!IsValid())
+        return NS_ERROR_UNEXPECTED;
+    return GetClass()->CallMethod(this, methodIndex, info, params);
+}
+
+NS_IMETHODIMP
+nsXPCWrappedJS::GetInterfaceIID(nsIID** iid)
+{
+    NS_PRECONDITION(iid, "bad param");
+
+    *iid = (nsIID*) nsMemory::Clone(&(GetIID()), sizeof(nsIID));
+    return *iid ? NS_OK : NS_ERROR_UNEXPECTED;
+}
+
+void
+nsXPCWrappedJS::SystemIsBeingShutDown()
+{
+    // XXX It turns out that it is better to leak here then to do any Releases
+    // and have them propagate into all sorts of mischief as the system is being
+    // shutdown. This was learned the hard way :(
+
+    // mJSObj == nullptr is used to indicate that the wrapper is no longer valid
+    // and that calls should fail without trying to use any of the
+    // xpconnect mechanisms. 'IsValid' is implemented by checking this pointer.
+
+    // NOTE: that mClass is retained so that GetInterfaceInfo can continue to
+    // work (and avoid crashing some platforms).
+
+    // Use of unsafeGet() is to avoid triggering post barriers in shutdown, as
+    // this will access the chunk containing mJSObj, which may have been freed
+    // at this point.
+    *mJSObj.unsafeGet() = nullptr;
+
+    // Notify other wrappers in the chain.
+    if (mNext)
+        mNext->SystemIsBeingShutDown();
+}
+
+size_t
+nsXPCWrappedJS::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+    // mJSObject is a JS pointer, so don't measure the object.
+    // mClass is not uniquely owned by this WrappedJS. Measure it in IID2WrappedJSClassMap.
+    // mRoot is not measured because it is either |this| or we have already measured it.
+    // mOuter is rare and probably not uniquely owned by this.
+    size_t n = mallocSizeOf(this);
+    n += nsAutoXPTCStub::SizeOfExcludingThis(mallocSizeOf);
+
+    // Wrappers form a linked list via the mNext field, so include them all
+    // in the measurement. Only root wrappers are stored in the map, so
+    // everything will be measured exactly once.
+    if (mNext)
+        n += mNext->SizeOfIncludingThis(mallocSizeOf);
+
+    return n;
+}
+
+/***************************************************************************/
+
+NS_IMETHODIMP
+nsXPCWrappedJS::GetEnumerator(nsISimpleEnumerator * *aEnumerate)
+{
+    AutoJSContext cx;
+    XPCCallContext ccx(cx);
+    if (!ccx.IsValid())
+        return NS_ERROR_UNEXPECTED;
+
+    return nsXPCWrappedJSClass::BuildPropertyEnumerator(ccx, GetJSObject(),
+                                                        aEnumerate);
+}
+
+NS_IMETHODIMP
+nsXPCWrappedJS::GetProperty(const nsAString & name, nsIVariant** _retval)
+{
+    AutoJSContext cx;
+    XPCCallContext ccx(cx);
+    if (!ccx.IsValid())
+        return NS_ERROR_UNEXPECTED;
+
+    return nsXPCWrappedJSClass::
+        GetNamedPropertyAsVariant(ccx, GetJSObject(), name, _retval);
+}
+
+/***************************************************************************/
+
+NS_IMETHODIMP
+nsXPCWrappedJS::DebugDump(int16_t depth)
+{
+#ifdef DEBUG
+    XPC_LOG_ALWAYS(("nsXPCWrappedJS @ %x with mRefCnt = %d", this, mRefCnt.get()));
+        XPC_LOG_INDENT();
+
+        XPC_LOG_ALWAYS(("%s wrapper around JSObject @ %x", \
+                        IsRootWrapper() ? "ROOT":"non-root", mJSObj.get()));
+        char* name;
+        GetClass()->GetInterfaceInfo()->GetName(&name);
+        XPC_LOG_ALWAYS(("interface name is %s", name));
+        if (name)
+            free(name);
+        char * iid = GetClass()->GetIID().ToString();
+        XPC_LOG_ALWAYS(("IID number is %s", iid ? iid : "invalid"));
+        if (iid)
+            free(iid);
+        XPC_LOG_ALWAYS(("nsXPCWrappedJSClass @ %x", mClass.get()));
+
+        if (!IsRootWrapper())
+            XPC_LOG_OUTDENT();
+        if (mNext) {
+            if (IsRootWrapper()) {
+                XPC_LOG_ALWAYS(("Additional wrappers for this object..."));
+                XPC_LOG_INDENT();
+            }
+            mNext->DebugDump(depth);
+            if (IsRootWrapper())
+                XPC_LOG_OUTDENT();
+        }
+        if (IsRootWrapper())
+            XPC_LOG_OUTDENT();
+#endif
+    return NS_OK;
+}
diff --git a/js/xpconnect/src/XPCWrappedJSClass.cpp b/js/xpconnect/src/XPCWrappedJSClass.cpp
new file mode 100644
index 000000000..2c9fd66bc
--- /dev/null
+++ b/js/xpconnect/src/XPCWrappedJSClass.cpp
@@ -0,0 +1,1457 @@
+/* -*- 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/. */
+
+/* Sharable code and data for wrapper around JSObjects. */
+
+#include "xpcprivate.h"
+#include "jsprf.h"
+#include "nsArrayEnumerator.h"
+#include "nsContentUtils.h"
+#include "nsWrapperCache.h"
+#include "AccessCheck.h"
+#include "nsJSUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/DOMExceptionBinding.h"
+#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
+
+#include "jsapi.h"
+#include "jsfriendapi.h"
+
+using namespace xpc;
+using namespace JS;
+using namespace mozilla;
+using namespace mozilla::dom;
+
+NS_IMPL_ISUPPORTS(nsXPCWrappedJSClass, nsIXPCWrappedJSClass)
+
+// the value of this variable is never used - we use its address as a sentinel
+static uint32_t zero_methods_descriptor;
+
+bool AutoScriptEvaluate::StartEvaluating(HandleObject scope)
+{
+    NS_PRECONDITION(!mEvaluated, "AutoScriptEvaluate::Evaluate should only be called once");
+
+    if (!mJSContext)
+        return true;
+
+    mEvaluated = true;
+
+    JS_BeginRequest(mJSContext);
+    mAutoCompartment.emplace(mJSContext, scope);
+
+    // Saving the exception state keeps us from interfering with another script
+    // that may also be running on this context.  This occurred first with the
+    // js debugger, as described in
+    // http://bugzilla.mozilla.org/show_bug.cgi?id=88130 but presumably could
+    // show up in any situation where a script calls into a wrapped js component
+    // on the same context, while the context has a nonzero exception state.
+    mState.emplace(mJSContext);
+
+    return true;
+}
+
+AutoScriptEvaluate::~AutoScriptEvaluate()
+{
+    if (!mJSContext || !mEvaluated)
+        return;
+    mState->restore();
+
+    JS_EndRequest(mJSContext);
+}
+
+// It turns out that some errors may be not worth reporting. So, this
+// function is factored out to manage that.
+bool xpc_IsReportableErrorCode(nsresult code)
+{
+    if (NS_SUCCEEDED(code))
+        return false;
+
+    switch (code) {
+        // Error codes that we don't want to report as errors...
+        // These generally indicate bad interface design AFAIC.
+        case NS_ERROR_FACTORY_REGISTER_AGAIN:
+        case NS_BASE_STREAM_WOULD_BLOCK:
+            return false;
+        default:
+            return true;
+    }
+}
+
+// A little stack-based RAII class to help management of the XPCJSContext
+// PendingResult.
+class MOZ_STACK_CLASS AutoSavePendingResult {
+public:
+    explicit AutoSavePendingResult(XPCJSContext* xpccx) :
+        mXPCContext(xpccx)
+    {
+        // Save any existing pending result and reset to NS_OK for this invocation.
+        mSavedResult = xpccx->GetPendingResult();
+        xpccx->SetPendingResult(NS_OK);
+    }
+    ~AutoSavePendingResult() {
+        mXPCContext->SetPendingResult(mSavedResult);
+    }
+private:
+    XPCJSContext* mXPCContext;
+    nsresult mSavedResult;
+};
+
+// static
+already_AddRefed<nsXPCWrappedJSClass>
+nsXPCWrappedJSClass::GetNewOrUsed(JSContext* cx, REFNSIID aIID, bool allowNonScriptable)
+{
+    XPCJSContext* xpccx = nsXPConnect::GetContextInstance();
+    IID2WrappedJSClassMap* map = xpccx->GetWrappedJSClassMap();
+    RefPtr<nsXPCWrappedJSClass> clasp = map->Find(aIID);
+
+    if (!clasp) {
+        nsCOMPtr<nsIInterfaceInfo> info;
+        nsXPConnect::XPConnect()->GetInfoForIID(&aIID, getter_AddRefs(info));
+        if (info) {
+            bool canScript, isBuiltin;
+            if (NS_SUCCEEDED(info->IsScriptable(&canScript)) && (canScript || allowNonScriptable) &&
+                NS_SUCCEEDED(info->IsBuiltinClass(&isBuiltin)) && !isBuiltin &&
+                nsXPConnect::IsISupportsDescendant(info))
+            {
+                clasp = new nsXPCWrappedJSClass(cx, aIID, info);
+                if (!clasp->mDescriptors)
+                    clasp = nullptr;
+            }
+        }
+    }
+    return clasp.forget();
+}
+
+nsXPCWrappedJSClass::nsXPCWrappedJSClass(JSContext* cx, REFNSIID aIID,
+                                         nsIInterfaceInfo* aInfo)
+    : mContext(nsXPConnect::GetContextInstance()),
+      mInfo(aInfo),
+      mName(nullptr),
+      mIID(aIID),
+      mDescriptors(nullptr)
+{
+    mContext->GetWrappedJSClassMap()->Add(this);
+
+    uint16_t methodCount;
+    if (NS_SUCCEEDED(mInfo->GetMethodCount(&methodCount))) {
+        if (methodCount) {
+            int wordCount = (methodCount/32)+1;
+            if (nullptr != (mDescriptors = new uint32_t[wordCount])) {
+                int i;
+                // init flags to 0;
+                for (i = wordCount-1; i >= 0; i--)
+                    mDescriptors[i] = 0;
+
+                for (i = 0; i < methodCount; i++) {
+                    const nsXPTMethodInfo* info;
+                    if (NS_SUCCEEDED(mInfo->GetMethodInfo(i, &info)))
+                        SetReflectable(i, XPCConvert::IsMethodReflectable(*info));
+                    else {
+                        delete [] mDescriptors;
+                        mDescriptors = nullptr;
+                        break;
+                    }
+                }
+            }
+        } else {
+            mDescriptors = &zero_methods_descriptor;
+        }
+    }
+}
+
+nsXPCWrappedJSClass::~nsXPCWrappedJSClass()
+{
+    if (mDescriptors && mDescriptors != &zero_methods_descriptor)
+        delete [] mDescriptors;
+    if (mContext)
+        mContext->GetWrappedJSClassMap()->Remove(this);
+
+    if (mName)
+        free(mName);
+}
+
+JSObject*
+nsXPCWrappedJSClass::CallQueryInterfaceOnJSObject(JSContext* cx,
+                                                  JSObject* jsobjArg,
+                                                  REFNSIID aIID)
+{
+    RootedObject jsobj(cx, jsobjArg);
+    JSObject* id;
+    RootedValue retval(cx);
+    RootedObject retObj(cx);
+    bool success = false;
+    RootedValue fun(cx);
+
+    // In bug 503926, we added a security check to make sure that we don't
+    // invoke content QI functions. In the modern world, this is probably
+    // unnecessary, because invoking QI involves passing an IID object to
+    // content, which will fail. But we do a belt-and-suspenders check to
+    // make sure that content can never trigger the rat's nest of code below.
+    // Once we completely turn off XPConnect for the web, this can definitely
+    // go away.
+    if (!AccessCheck::isChrome(jsobj) ||
+        !AccessCheck::isChrome(js::UncheckedUnwrap(jsobj)))
+    {
+        return nullptr;
+    }
+
+    // OK, it looks like we'll be calling into JS code.
+    AutoScriptEvaluate scriptEval(cx);
+
+    // XXX we should install an error reporter that will send reports to
+    // the JS error console service.
+    if (!scriptEval.StartEvaluating(jsobj))
+        return nullptr;
+
+    // check upfront for the existence of the function property
+    HandleId funid = mContext->GetStringID(XPCJSContext::IDX_QUERY_INTERFACE);
+    if (!JS_GetPropertyById(cx, jsobj, funid, &fun) || fun.isPrimitive())
+        return nullptr;
+
+    // Ensure that we are asking for a scriptable interface.
+    // NB:  It's important for security that this check is here rather
+    // than later, since it prevents untrusted objects from implementing
+    // some interfaces in JS and aggregating a trusted object to
+    // implement intentionally (for security) unscriptable interfaces.
+    // We so often ask for nsISupports that we can short-circuit the test...
+    if (!aIID.Equals(NS_GET_IID(nsISupports))) {
+        bool allowNonScriptable = mozilla::jsipc::IsWrappedCPOW(jsobj);
+
+        nsCOMPtr<nsIInterfaceInfo> info;
+        nsXPConnect::XPConnect()->GetInfoForIID(&aIID, getter_AddRefs(info));
+        if (!info)
+            return nullptr;
+        bool canScript, isBuiltin;
+        if (NS_FAILED(info->IsScriptable(&canScript)) || (!canScript && !allowNonScriptable) ||
+            NS_FAILED(info->IsBuiltinClass(&isBuiltin)) || isBuiltin)
+            return nullptr;
+    }
+
+    id = xpc_NewIDObject(cx, jsobj, aIID);
+    if (id) {
+        // Throwing NS_NOINTERFACE is the prescribed way to fail QI from JS. It
+        // is not an exception that is ever worth reporting, but we don't want
+        // to eat all exceptions either.
+
+        {
+            RootedValue arg(cx, JS::ObjectValue(*id));
+            success = JS_CallFunctionValue(cx, jsobj, fun, HandleValueArray(arg), &retval);
+        }
+
+        if (!success && JS_IsExceptionPending(cx)) {
+            RootedValue jsexception(cx, NullValue());
+
+            if (JS_GetPendingException(cx, &jsexception)) {
+                nsresult rv;
+                if (jsexception.isObject()) {
+                    // XPConnect may have constructed an object to represent a
+                    // C++ QI failure. See if that is the case.
+                    JS::Rooted<JSObject*> exceptionObj(cx, &jsexception.toObject());
+                    Exception* e = nullptr;
+                    UNWRAP_OBJECT(Exception, &exceptionObj, e);
+
+                    if (e &&
+                        NS_SUCCEEDED(e->GetResult(&rv)) &&
+                        rv == NS_NOINTERFACE) {
+                        JS_ClearPendingException(cx);
+                    }
+                } else if (jsexception.isNumber()) {
+                    // JS often throws an nsresult.
+                    if (jsexception.isDouble())
+                        // Visual Studio 9 doesn't allow casting directly from
+                        // a double to an enumeration type, contrary to
+                        // 5.2.9(10) of C++11, so add an intermediate cast.
+                        rv = (nsresult)(uint32_t)(jsexception.toDouble());
+                    else
+                        rv = (nsresult)(jsexception.toInt32());
+
+                    if (rv == NS_NOINTERFACE)
+                        JS_ClearPendingException(cx);
+                }
+            }
+        } else if (!success) {
+            NS_WARNING("QI hook ran OOMed - this is probably a bug!");
+        }
+    }
+
+    if (success)
+        success = JS_ValueToObject(cx, retval, &retObj);
+
+    return success ? retObj.get() : nullptr;
+}
+
+/***************************************************************************/
+
+static bool
+GetNamedPropertyAsVariantRaw(XPCCallContext& ccx,
+                             HandleObject aJSObj,
+                             HandleId aName,
+                             nsIVariant** aResult,
+                             nsresult* pErr)
+{
+    nsXPTType type = nsXPTType((uint8_t)TD_INTERFACE_TYPE);
+    RootedValue val(ccx);
+
+    return JS_GetPropertyById(ccx, aJSObj, aName, &val) &&
+           XPCConvert::JSData2Native(aResult, val, type,
+                                     &NS_GET_IID(nsIVariant), pErr);
+}
+
+// static
+nsresult
+nsXPCWrappedJSClass::GetNamedPropertyAsVariant(XPCCallContext& ccx,
+                                               JSObject* aJSObjArg,
+                                               const nsAString& aName,
+                                               nsIVariant** aResult)
+{
+    JSContext* cx = ccx.GetJSContext();
+    RootedObject aJSObj(cx, aJSObjArg);
+
+    AutoScriptEvaluate scriptEval(cx);
+    if (!scriptEval.StartEvaluating(aJSObj))
+        return NS_ERROR_FAILURE;
+
+    // Wrap the string in a Value after the AutoScriptEvaluate, so that the
+    // resulting value ends up in the correct compartment.
+    nsStringBuffer* buf;
+    RootedValue value(cx);
+    if (!XPCStringConvert::ReadableToJSVal(ccx, aName, &buf, &value))
+        return NS_ERROR_OUT_OF_MEMORY;
+    if (buf)
+        buf->AddRef();
+
+    RootedId id(cx);
+    nsresult rv = NS_OK;
+    if (!JS_ValueToId(cx, value, &id) ||
+        !GetNamedPropertyAsVariantRaw(ccx, aJSObj, id, aResult, &rv)) {
+        if (NS_FAILED(rv))
+            return rv;
+        return NS_ERROR_FAILURE;
+    }
+    return NS_OK;
+}
+
+/***************************************************************************/
+
+// static
+nsresult
+nsXPCWrappedJSClass::BuildPropertyEnumerator(XPCCallContext& ccx,
+                                             JSObject* aJSObjArg,
+                                             nsISimpleEnumerator** aEnumerate)
+{
+    JSContext* cx = ccx.GetJSContext();
+    RootedObject aJSObj(cx, aJSObjArg);
+
+    AutoScriptEvaluate scriptEval(cx);
+    if (!scriptEval.StartEvaluating(aJSObj))
+        return NS_ERROR_FAILURE;
+
+    Rooted<IdVector> idArray(cx, IdVector(cx));
+    if (!JS_Enumerate(cx, aJSObj, &idArray))
+        return NS_ERROR_FAILURE;
+
+    nsCOMArray<nsIProperty> propertyArray(idArray.length());
+    RootedId idName(cx);
+    for (size_t i = 0; i < idArray.length(); i++) {
+        idName = idArray[i];
+
+        nsCOMPtr<nsIVariant> value;
+        nsresult rv;
+        if (!GetNamedPropertyAsVariantRaw(ccx, aJSObj, idName,
+                                          getter_AddRefs(value), &rv)) {
+            if (NS_FAILED(rv))
+                return rv;
+            return NS_ERROR_FAILURE;
+        }
+
+        RootedValue jsvalName(cx);
+        if (!JS_IdToValue(cx, idName, &jsvalName))
+            return NS_ERROR_FAILURE;
+
+        JSString* name = ToString(cx, jsvalName);
+        if (!name)
+            return NS_ERROR_FAILURE;
+
+        nsAutoJSString autoStr;
+        if (!autoStr.init(cx, name))
+            return NS_ERROR_FAILURE;
+
+        nsCOMPtr<nsIProperty> property =
+            new xpcProperty(autoStr.get(), (uint32_t)autoStr.Length(), value);
+
+        if (!propertyArray.AppendObject(property))
+            return NS_ERROR_FAILURE;
+    }
+
+    return NS_NewArrayEnumerator(aEnumerate, propertyArray);
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(xpcProperty, nsIProperty)
+
+xpcProperty::xpcProperty(const char16_t* aName, uint32_t aNameLen,
+                         nsIVariant* aValue)
+    : mName(aName, aNameLen), mValue(aValue)
+{
+}
+
+NS_IMETHODIMP xpcProperty::GetName(nsAString & aName)
+{
+    aName.Assign(mName);
+    return NS_OK;
+}
+
+NS_IMETHODIMP xpcProperty::GetValue(nsIVariant * *aValue)
+{
+    nsCOMPtr<nsIVariant> rval = mValue;
+    rval.forget(aValue);
+    return NS_OK;
+}
+
+/***************************************************************************/
+// This 'WrappedJSIdentity' class and singleton allow us to figure out if
+// any given nsISupports* is implemented by a WrappedJS object. This is done
+// using a QueryInterface call on the interface pointer with our ID. If
+// that call returns NS_OK and the pointer is to our singleton, then the
+// interface must be implemented by a WrappedJS object. NOTE: the
+// 'WrappedJSIdentity' object is not a real XPCOM object and should not be
+// used for anything else (hence it is declared in this implementation file).
+
+// {5C5C3BB0-A9BA-11d2-BA64-00805F8A5DD7}
+#define NS_IXPCONNECT_WRAPPED_JS_IDENTITY_CLASS_IID                           \
+{ 0x5c5c3bb0, 0xa9ba, 0x11d2,                                                 \
+  { 0xba, 0x64, 0x0, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 } }
+
+class WrappedJSIdentity
+{
+    // no instance methods...
+public:
+    NS_DECLARE_STATIC_IID_ACCESSOR(NS_IXPCONNECT_WRAPPED_JS_IDENTITY_CLASS_IID)
+
+    static void* GetSingleton()
+    {
+        static WrappedJSIdentity* singleton = nullptr;
+        if (!singleton)
+            singleton = new WrappedJSIdentity();
+        return (void*) singleton;
+    }
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(WrappedJSIdentity,
+                              NS_IXPCONNECT_WRAPPED_JS_IDENTITY_CLASS_IID)
+
+/***************************************************************************/
+
+// static
+bool
+nsXPCWrappedJSClass::IsWrappedJS(nsISupports* aPtr)
+{
+    void* result;
+    NS_PRECONDITION(aPtr, "null pointer");
+    return aPtr &&
+           NS_OK == aPtr->QueryInterface(NS_GET_IID(WrappedJSIdentity), &result) &&
+           result == WrappedJSIdentity::GetSingleton();
+}
+
+NS_IMETHODIMP
+nsXPCWrappedJSClass::DelegatedQueryInterface(nsXPCWrappedJS* self,
+                                             REFNSIID aIID,
+                                             void** aInstancePtr)
+{
+    if (aIID.Equals(NS_GET_IID(nsIXPConnectJSObjectHolder))) {
+        NS_ADDREF(self);
+        *aInstancePtr = (void*) static_cast<nsIXPConnectJSObjectHolder*>(self);
+        return NS_OK;
+    }
+
+    // Objects internal to xpconnect are the only objects that even know *how*
+    // to ask for this iid. And none of them bother refcounting the thing.
+    if (aIID.Equals(NS_GET_IID(WrappedJSIdentity))) {
+        // asking to find out if this is a wrapper object
+        *aInstancePtr = WrappedJSIdentity::GetSingleton();
+        return NS_OK;
+    }
+
+    if (aIID.Equals(NS_GET_IID(nsIPropertyBag))) {
+        // We only want to expose one implementation from our aggregate.
+        nsXPCWrappedJS* root = self->GetRootWrapper();
+
+        if (!root->IsValid()) {
+            *aInstancePtr = nullptr;
+            return NS_NOINTERFACE;
+        }
+
+        NS_ADDREF(root);
+        *aInstancePtr = (void*) static_cast<nsIPropertyBag*>(root);
+        return NS_OK;
+    }
+
+    // We can't have a cached wrapper.
+    if (aIID.Equals(NS_GET_IID(nsWrapperCache))) {
+        *aInstancePtr = nullptr;
+        return NS_NOINTERFACE;
+    }
+
+    // QI on an XPCWrappedJS can run script, so we need an AutoEntryScript.
+    // This is inherently Gecko-specific.
+    // We check both nativeGlobal and nativeGlobal->GetGlobalJSObject() even
+    // though we have derived nativeGlobal from the JS global, because we know
+    // there are cases where this can happen. See bug 1094953.
+    nsIGlobalObject* nativeGlobal =
+      NativeGlobal(js::GetGlobalForObjectCrossCompartment(self->GetJSObject()));
+    NS_ENSURE_TRUE(nativeGlobal, NS_ERROR_FAILURE);
+    NS_ENSURE_TRUE(nativeGlobal->GetGlobalJSObject(), NS_ERROR_FAILURE);
+    AutoEntryScript aes(nativeGlobal, "XPCWrappedJS QueryInterface",
+                        /* aIsMainThread = */ true);
+    XPCCallContext ccx(aes.cx());
+    if (!ccx.IsValid()) {
+        *aInstancePtr = nullptr;
+        return NS_NOINTERFACE;
+    }
+
+    // We support nsISupportsWeakReference iff the root wrapped JSObject
+    // claims to support it in its QueryInterface implementation.
+    if (aIID.Equals(NS_GET_IID(nsISupportsWeakReference))) {
+        // We only want to expose one implementation from our aggregate.
+        nsXPCWrappedJS* root = self->GetRootWrapper();
+
+        // Fail if JSObject doesn't claim support for nsISupportsWeakReference
+        if (!root->IsValid() ||
+            !CallQueryInterfaceOnJSObject(ccx, root->GetJSObject(), aIID)) {
+            *aInstancePtr = nullptr;
+            return NS_NOINTERFACE;
+        }
+
+        NS_ADDREF(root);
+        *aInstancePtr = (void*) static_cast<nsISupportsWeakReference*>(root);
+        return NS_OK;
+    }
+
+    // Checks for any existing wrapper explicitly constructed for this iid.
+    // This includes the current 'self' wrapper. This also deals with the
+    // nsISupports case (for which it returns mRoot).
+    // Also check if asking for an interface from which one of our wrappers inherits.
+    if (nsXPCWrappedJS* sibling = self->FindOrFindInherited(aIID)) {
+        NS_ADDREF(sibling);
+        *aInstancePtr = sibling->GetXPTCStub();
+        return NS_OK;
+    }
+
+    // Check if the desired interface is a function interface. If so, we don't
+    // want to QI, because the function almost certainly doesn't have a QueryInterface
+    // property, and doesn't need one.
+    bool isFunc = false;
+    nsCOMPtr<nsIInterfaceInfo> info;
+    nsXPConnect::XPConnect()->GetInfoForIID(&aIID, getter_AddRefs(info));
+    if (info && NS_SUCCEEDED(info->IsFunction(&isFunc)) && isFunc) {
+        RefPtr<nsXPCWrappedJS> wrapper;
+        RootedObject obj(RootingCx(), self->GetJSObject());
+        nsresult rv = nsXPCWrappedJS::GetNewOrUsed(obj, aIID, getter_AddRefs(wrapper));
+
+        // Do the same thing we do for the "check for any existing wrapper" case above.
+        if (NS_SUCCEEDED(rv) && wrapper) {
+            *aInstancePtr = wrapper.forget().take()->GetXPTCStub();
+        }
+        return rv;
+    }
+
+    // else we do the more expensive stuff...
+
+    // check if the JSObject claims to implement this interface
+    RootedObject jsobj(ccx, CallQueryInterfaceOnJSObject(ccx, self->GetJSObject(),
+                                                         aIID));
+    if (jsobj) {
+        // We can't use XPConvert::JSObject2NativeInterface() here
+        // since that can find a XPCWrappedNative directly on the
+        // proto chain, and we don't want that here. We need to find
+        // the actual JS object that claimed it supports the interface
+        // we're looking for or we'll potentially bypass security
+        // checks etc by calling directly through to a native found on
+        // the prototype chain.
+        //
+        // Instead, simply do the nsXPCWrappedJS part of
+        // XPConvert::JSObject2NativeInterface() here to make sure we
+        // get a new (or used) nsXPCWrappedJS.
+        RefPtr<nsXPCWrappedJS> wrapper;
+        nsresult rv = nsXPCWrappedJS::GetNewOrUsed(jsobj, aIID, getter_AddRefs(wrapper));
+        if (NS_SUCCEEDED(rv) && wrapper) {
+            // We need to go through the QueryInterface logic to make
+            // this return the right thing for the various 'special'
+            // interfaces; e.g.  nsIPropertyBag.
+            rv = wrapper->QueryInterface(aIID, aInstancePtr);
+            return rv;
+        }
+    }
+
+    // else...
+    // no can do
+    *aInstancePtr = nullptr;
+    return NS_NOINTERFACE;
+}
+
+JSObject*
+nsXPCWrappedJSClass::GetRootJSObject(JSContext* cx, JSObject* aJSObjArg)
+{
+    RootedObject aJSObj(cx, aJSObjArg);
+    JSObject* result = CallQueryInterfaceOnJSObject(cx, aJSObj,
+                                                    NS_GET_IID(nsISupports));
+    if (!result)
+        result = aJSObj;
+    JSObject* inner = js::UncheckedUnwrap(result);
+    if (inner)
+        return inner;
+    return result;
+}
+
+bool
+nsXPCWrappedJSClass::GetArraySizeFromParam(JSContext* cx,
+                                           const XPTMethodDescriptor* method,
+                                           const nsXPTParamInfo& param,
+                                           uint16_t methodIndex,
+                                           uint8_t paramIndex,
+                                           nsXPTCMiniVariant* nativeParams,
+                                           uint32_t* result) const
+{
+    uint8_t argnum;
+    nsresult rv;
+
+    rv = mInfo->GetSizeIsArgNumberForParam(methodIndex, &param, 0, &argnum);
+    if (NS_FAILED(rv))
+        return false;
+
+    const nsXPTParamInfo& arg_param = method->params[argnum];
+
+    // This should be enforced by the xpidl compiler, but it's not.
+    // See bug 695235.
+    MOZ_ASSERT(arg_param.GetType().TagPart() == nsXPTType::T_U32,
+               "size_is references parameter of invalid type.");
+
+    if (arg_param.IsIndirect())
+        *result = *(uint32_t*)nativeParams[argnum].val.p;
+    else
+        *result = nativeParams[argnum].val.u32;
+
+    return true;
+}
+
+bool
+nsXPCWrappedJSClass::GetInterfaceTypeFromParam(JSContext* cx,
+                                               const XPTMethodDescriptor* method,
+                                               const nsXPTParamInfo& param,
+                                               uint16_t methodIndex,
+                                               const nsXPTType& type,
+                                               nsXPTCMiniVariant* nativeParams,
+                                               nsID* result) const
+{
+    uint8_t type_tag = type.TagPart();
+
+    if (type_tag == nsXPTType::T_INTERFACE) {
+        if (NS_SUCCEEDED(GetInterfaceInfo()->
+                         GetIIDForParamNoAlloc(methodIndex, &param, result))) {
+            return true;
+        }
+    } else if (type_tag == nsXPTType::T_INTERFACE_IS) {
+        uint8_t argnum;
+        nsresult rv;
+        rv = mInfo->GetInterfaceIsArgNumberForParam(methodIndex,
+                                                    &param, &argnum);
+        if (NS_FAILED(rv))
+            return false;
+
+        const nsXPTParamInfo& arg_param = method->params[argnum];
+        const nsXPTType& arg_type = arg_param.GetType();
+
+        if (arg_type.TagPart() == nsXPTType::T_IID) {
+            if (arg_param.IsIndirect()) {
+                nsID** p = (nsID**) nativeParams[argnum].val.p;
+                if (!p || !*p)
+                    return false;
+                *result = **p;
+            } else {
+                nsID* p = (nsID*) nativeParams[argnum].val.p;
+                if (!p)
+                    return false;
+                *result = *p;
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+/* static */ void
+nsXPCWrappedJSClass::CleanupPointerArray(const nsXPTType& datum_type,
+                                         uint32_t array_count,
+                                         void** arrayp)
+{
+    if (datum_type.IsInterfacePointer()) {
+        nsISupports** pp = (nsISupports**) arrayp;
+        for (uint32_t k = 0; k < array_count; k++) {
+            nsISupports* p = pp[k];
+            NS_IF_RELEASE(p);
+        }
+    } else {
+        void** pp = (void**) arrayp;
+        for (uint32_t k = 0; k < array_count; k++) {
+            void* p = pp[k];
+            if (p) free(p);
+        }
+    }
+}
+
+/* static */ void
+nsXPCWrappedJSClass::CleanupPointerTypeObject(const nsXPTType& type,
+                                              void** pp)
+{
+    MOZ_ASSERT(pp,"null pointer");
+    if (type.IsInterfacePointer()) {
+        nsISupports* p = *((nsISupports**)pp);
+        if (p) p->Release();
+    } else {
+        void* p = *((void**)pp);
+        if (p) free(p);
+    }
+}
+
+void
+nsXPCWrappedJSClass::CleanupOutparams(JSContext* cx, uint16_t methodIndex,
+                                      const nsXPTMethodInfo* info, nsXPTCMiniVariant* nativeParams,
+                                      bool inOutOnly, uint8_t n) const
+{
+    // clean up any 'out' params handed in
+    for (uint8_t i = 0; i < n; i++) {
+        const nsXPTParamInfo& param = info->params[i];
+        if (!param.IsOut())
+            continue;
+
+        const nsXPTType& type = param.GetType();
+        if (!type.deprecated_IsPointer())
+            continue;
+        void* p = nativeParams[i].val.p;
+        if (!p)
+            continue;
+
+        // The inOutOnly flag was introduced when consolidating two very
+        // similar code paths in CallMethod in bug 1175513. I don't know
+        // if and why the difference is necessary.
+        if (!inOutOnly || param.IsIn()) {
+            if (type.IsArray()) {
+                void** pp = *static_cast<void***>(p);
+                if (pp) {
+                    // we need to get the array length and iterate the items
+                    uint32_t array_count;
+                    nsXPTType datum_type;
+
+                    if (NS_SUCCEEDED(mInfo->GetTypeForParam(methodIndex, &param,
+                                                            1, &datum_type)) &&
+                        datum_type.deprecated_IsPointer() &&
+                        GetArraySizeFromParam(cx, info, param, methodIndex,
+                                              i, nativeParams, &array_count) &&
+                        array_count) {
+
+                        CleanupPointerArray(datum_type, array_count, pp);
+                    }
+
+                    // always release the array if it is inout
+                    free(pp);
+                }
+            } else {
+                CleanupPointerTypeObject(type, static_cast<void**>(p));
+            }
+        }
+        *static_cast<void**>(p) = nullptr;
+    }
+}
+
+nsresult
+nsXPCWrappedJSClass::CheckForException(XPCCallContext & ccx,
+                                       AutoEntryScript& aes,
+                                       const char * aPropertyName,
+                                       const char * anInterfaceName,
+                                       nsIException* aSyntheticException)
+{
+    JSContext * cx = ccx.GetJSContext();
+    MOZ_ASSERT(cx == aes.cx());
+    nsCOMPtr<nsIException> xpc_exception = aSyntheticException;
+    /* this one would be set by our error reporter */
+
+    XPCJSContext* xpccx = XPCJSContext::Get();
+
+    // Get this right away in case we do something below to cause JS code
+    // to run.
+    nsresult pending_result = xpccx->GetPendingResult();
+
+    RootedValue js_exception(cx);
+    bool is_js_exception = JS_GetPendingException(cx, &js_exception);
+
+    /* JS might throw an expection whether the reporter was called or not */
+    if (is_js_exception) {
+        if (!xpc_exception)
+            XPCConvert::JSValToXPCException(&js_exception, anInterfaceName,
+                                            aPropertyName,
+                                            getter_AddRefs(xpc_exception));
+
+        /* cleanup and set failed even if we can't build an exception */
+        if (!xpc_exception) {
+            xpccx->SetPendingException(nullptr); // XXX necessary?
+        }
+    }
+
+    // Clear the pending exception now, because xpc_exception might be JS-
+    // implemented, so invoking methods on it might re-enter JS, which we can't
+    // do with an exception on the stack.
+    aes.ClearException();
+
+    if (xpc_exception) {
+        nsresult e_result;
+        if (NS_SUCCEEDED(xpc_exception->GetResult(&e_result))) {
+            // Figure out whether or not we should report this exception.
+            bool reportable = xpc_IsReportableErrorCode(e_result);
+            if (reportable) {
+                // Ugly special case for GetInterface. It's "special" in the
+                // same way as QueryInterface in that a failure is not
+                // exceptional and shouldn't be reported. We have to do this
+                // check here instead of in xpcwrappedjs (like we do for QI) to
+                // avoid adding extra code to all xpcwrappedjs objects.
+                if (e_result == NS_ERROR_NO_INTERFACE &&
+                    !strcmp(anInterfaceName, "nsIInterfaceRequestor") &&
+                    !strcmp(aPropertyName, "getInterface")) {
+                    reportable = false;
+                }
+
+                // More special case, see bug 877760.
+                if (e_result == NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED) {
+                    reportable = false;
+                }
+            }
+
+            // Try to use the error reporter set on the context to handle this
+            // error if it came from a JS exception.
+            if (reportable && is_js_exception)
+            {
+                // Note that we cleared the exception above, so we need to set it again,
+                // just so that we can tell the JS engine to pass it back to us via the
+                // error reporting callback. This is all very dumb.
+                JS_SetPendingException(cx, js_exception);
+                aes.ReportException();
+                reportable = false;
+            }
+
+            if (reportable) {
+                if (nsContentUtils::DOMWindowDumpEnabled()) {
+                    static const char line[] =
+                        "************************************************************\n";
+                    static const char preamble[] =
+                        "* Call to xpconnect wrapped JSObject produced this error:  *\n";
+                    static const char cant_get_text[] =
+                        "FAILED TO GET TEXT FROM EXCEPTION\n";
+
+                    fputs(line, stdout);
+                    fputs(preamble, stdout);
+                    nsCString text;
+                    if (NS_SUCCEEDED(xpc_exception->ToString(cx, text)) &&
+                        !text.IsEmpty()) {
+                        fputs(text.get(), stdout);
+                        fputs("\n", stdout);
+                    } else
+                        fputs(cant_get_text, stdout);
+                    fputs(line, stdout);
+                }
+
+                // Log the exception to the JS Console, so that users can do
+                // something with it.
+                nsCOMPtr<nsIConsoleService> consoleService
+                    (do_GetService(XPC_CONSOLE_CONTRACTID));
+                if (nullptr != consoleService) {
+                    nsresult rv;
+                    nsCOMPtr<nsIScriptError> scriptError;
+                    nsCOMPtr<nsISupports> errorData;
+                    rv = xpc_exception->GetData(getter_AddRefs(errorData));
+                    if (NS_SUCCEEDED(rv))
+                        scriptError = do_QueryInterface(errorData);
+
+                    if (nullptr == scriptError) {
+                        // No luck getting one from the exception, so
+                        // try to cook one up.
+                        scriptError = do_CreateInstance(XPC_SCRIPT_ERROR_CONTRACTID);
+                        if (nullptr != scriptError) {
+                            nsCString newMessage;
+                            rv = xpc_exception->ToString(cx, newMessage);
+                            if (NS_SUCCEEDED(rv)) {
+                                // try to get filename, lineno from the first
+                                // stack frame location.
+                                int32_t lineNumber = 0;
+                                nsString sourceName;
+
+                                nsCOMPtr<nsIStackFrame> location;
+                                xpc_exception->
+                                    GetLocation(getter_AddRefs(location));
+                                if (location) {
+                                    // Get line number w/o checking; 0 is ok.
+                                    location->GetLineNumber(cx, &lineNumber);
+
+                                    // get a filename.
+                                    rv = location->GetFilename(cx, sourceName);
+                                }
+
+                                rv = scriptError->InitWithWindowID(NS_ConvertUTF8toUTF16(newMessage),
+                                                                   sourceName,
+                                                                   EmptyString(),
+                                                                   lineNumber, 0, 0,
+                                                                   "XPConnect JavaScript",
+                                                                   nsJSUtils::GetCurrentlyRunningCodeInnerWindowID(cx));
+                                if (NS_FAILED(rv))
+                                    scriptError = nullptr;
+                            }
+                        }
+                    }
+                    if (nullptr != scriptError)
+                        consoleService->LogMessage(scriptError);
+                }
+            }
+            // Whether or not it passes the 'reportable' test, it might
+            // still be an error and we have to do the right thing here...
+            if (NS_FAILED(e_result)) {
+                xpccx->SetPendingException(xpc_exception);
+                return e_result;
+            }
+        }
+    } else {
+        // see if JS code signaled failure result without throwing exception
+        if (NS_FAILED(pending_result)) {
+            return pending_result;
+        }
+    }
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsXPCWrappedJSClass::CallMethod(nsXPCWrappedJS* wrapper, uint16_t methodIndex,
+                                const XPTMethodDescriptor* info_,
+                                nsXPTCMiniVariant* nativeParams)
+{
+    Value* sp = nullptr;
+    Value* argv = nullptr;
+    uint8_t i;
+    nsresult retval = NS_ERROR_FAILURE;
+    bool success;
+    bool readyToDoTheCall = false;
+    nsID  param_iid;
+    const nsXPTMethodInfo* info = static_cast<const nsXPTMethodInfo*>(info_);
+    const char* name = info->name;
+    bool foundDependentParam;
+
+    // Make sure not to set the callee on ccx until after we've gone through
+    // the whole nsIXPCFunctionThisTranslator bit.  That code uses ccx to
+    // convert natives to JSObjects, but we do NOT plan to pass those JSObjects
+    // to our real callee.
+    //
+    // We're about to call into script via an XPCWrappedJS, so we need an
+    // AutoEntryScript. This is probably Gecko-specific at this point, and
+    // definitely will be when we turn off XPConnect for the web.
+    nsIGlobalObject* nativeGlobal =
+      NativeGlobal(js::GetGlobalForObjectCrossCompartment(wrapper->GetJSObject()));
+    AutoEntryScript aes(nativeGlobal, "XPCWrappedJS method call",
+                        /* aIsMainThread = */ true);
+    XPCCallContext ccx(aes.cx());
+    if (!ccx.IsValid())
+        return retval;
+
+    JSContext* cx = ccx.GetJSContext();
+
+    if (!cx || !IsReflectable(methodIndex))
+        return NS_ERROR_FAILURE;
+
+    // [implicit_jscontext] and [optional_argc] have a different calling
+    // convention, which we don't support for JS-implemented components.
+    if (info->WantsOptArgc() || info->WantsContext()) {
+        const char* str = "IDL methods marked with [implicit_jscontext] "
+                          "or [optional_argc] may not be implemented in JS";
+        // Throw and warn for good measure.
+        JS_ReportErrorASCII(cx, "%s", str);
+        NS_WARNING(str);
+        return CheckForException(ccx, aes, name, GetInterfaceName());
+    }
+
+    RootedValue fval(cx);
+    RootedObject obj(cx, wrapper->GetJSObject());
+    RootedObject thisObj(cx, obj);
+
+    JSAutoCompartment ac(cx, obj);
+
+    AutoValueVector args(cx);
+    AutoScriptEvaluate scriptEval(cx);
+
+    XPCJSContext* xpccx = XPCJSContext::Get();
+    AutoSavePendingResult apr(xpccx);
+
+    // XXX ASSUMES that retval is last arg. The xpidl compiler ensures this.
+    uint8_t paramCount = info->num_args;
+    uint8_t argc = paramCount -
+        (paramCount && XPT_PD_IS_RETVAL(info->params[paramCount-1].flags) ? 1 : 0);
+
+    if (!scriptEval.StartEvaluating(obj))
+        goto pre_call_clean_up;
+
+    xpccx->SetPendingException(nullptr);
+
+    // We use js_Invoke so that the gcthings we use as args will be rooted by
+    // the engine as we do conversions and prepare to do the function call.
+
+    // setup stack
+
+    // if this isn't a function call then we don't need to push extra stuff
+    if (!(XPT_MD_IS_SETTER(info->flags) || XPT_MD_IS_GETTER(info->flags))) {
+        // We get fval before allocating the stack to avoid gc badness that can
+        // happen if the GetProperty call leaves our request and the gc runs
+        // while the stack we allocate contains garbage.
+
+        // If the interface is marked as a [function] then we will assume that
+        // our JSObject is a function and not an object with a named method.
+
+        bool isFunction;
+        if (NS_FAILED(mInfo->IsFunction(&isFunction)))
+            goto pre_call_clean_up;
+
+        // In the xpidl [function] case we are making sure now that the
+        // JSObject is callable. If it is *not* callable then we silently
+        // fallback to looking up the named property...
+        // (because jst says he thinks this fallback is 'The Right Thing'.)
+        //
+        // In the normal (non-function) case we just lookup the property by
+        // name and as long as the object has such a named property we go ahead
+        // and try to make the call. If it turns out the named property is not
+        // a callable object then the JS engine will throw an error and we'll
+        // pass this along to the caller as an exception/result code.
+
+        fval = ObjectValue(*obj);
+        if (isFunction &&
+            JS_TypeOfValue(ccx, fval) == JSTYPE_FUNCTION) {
+
+            // We may need to translate the 'this' for the function object.
+
+            if (paramCount) {
+                const nsXPTParamInfo& firstParam = info->params[0];
+                if (firstParam.IsIn()) {
+                    const nsXPTType& firstType = firstParam.GetType();
+
+                    if (firstType.IsInterfacePointer()) {
+                        nsIXPCFunctionThisTranslator* translator;
+
+                        IID2ThisTranslatorMap* map =
+                            mContext->GetThisTranslatorMap();
+
+                        translator = map->Find(mIID);
+
+                        if (translator) {
+                            nsCOMPtr<nsISupports> newThis;
+                            if (NS_FAILED(translator->
+                                          TranslateThis((nsISupports*)nativeParams[0].val.p,
+                                                        getter_AddRefs(newThis)))) {
+                                goto pre_call_clean_up;
+                            }
+                            if (newThis) {
+                                RootedValue v(cx);
+                                xpcObjectHelper helper(newThis);
+                                bool ok =
+                                  XPCConvert::NativeInterface2JSObject(
+                                      &v, nullptr, helper, nullptr,
+                                      false, nullptr);
+                                if (!ok) {
+                                    goto pre_call_clean_up;
+                                }
+                                thisObj = v.toObjectOrNull();
+                                if (!JS_WrapObject(cx, &thisObj))
+                                    goto pre_call_clean_up;
+                            }
+                        }
+                    }
+                }
+            }
+        } else {
+            if (!JS_GetProperty(cx, obj, name, &fval))
+                goto pre_call_clean_up;
+            // XXX We really want to factor out the error reporting better and
+            // specifically report the failure to find a function with this name.
+            // This is what we do below if the property is found but is not a
+            // function. We just need to factor better so we can get to that
+            // reporting path from here.
+
+            thisObj = obj;
+        }
+    }
+
+    if (!args.resize(argc)) {
+        retval = NS_ERROR_OUT_OF_MEMORY;
+        goto pre_call_clean_up;
+    }
+
+    argv = args.begin();
+    sp = argv;
+
+    // build the args
+    // NB: This assignment *looks* wrong because we haven't yet called our
+    // function. However, we *have* already entered the compartmen that we're
+    // about to call, and that's the global that we want here. In other words:
+    // we're trusting the JS engine to come up with a good global to use for
+    // our object (whatever it was).
+    for (i = 0; i < argc; i++) {
+        const nsXPTParamInfo& param = info->params[i];
+        const nsXPTType& type = param.GetType();
+        nsXPTType datum_type;
+        uint32_t array_count;
+        bool isArray = type.IsArray();
+        RootedValue val(cx, NullValue());
+        bool isSizedString = isArray ?
+                false :
+                type.TagPart() == nsXPTType::T_PSTRING_SIZE_IS ||
+                type.TagPart() == nsXPTType::T_PWSTRING_SIZE_IS;
+
+
+        // verify that null was not passed for 'out' param
+        if (param.IsOut() && !nativeParams[i].val.p) {
+            retval = NS_ERROR_INVALID_ARG;
+            goto pre_call_clean_up;
+        }
+
+        if (isArray) {
+            if (NS_FAILED(mInfo->GetTypeForParam(methodIndex, &param, 1,
+                                                 &datum_type)))
+                goto pre_call_clean_up;
+        } else
+            datum_type = type;
+
+        if (param.IsIn()) {
+            nsXPTCMiniVariant* pv;
+
+            if (param.IsIndirect())
+                pv = (nsXPTCMiniVariant*) nativeParams[i].val.p;
+            else
+                pv = &nativeParams[i];
+
+            if (datum_type.IsInterfacePointer() &&
+                !GetInterfaceTypeFromParam(cx, info, param, methodIndex,
+                                           datum_type, nativeParams,
+                                           &param_iid))
+                goto pre_call_clean_up;
+
+            if (isArray || isSizedString) {
+                if (!GetArraySizeFromParam(cx, info, param, methodIndex,
+                                           i, nativeParams, &array_count))
+                    goto pre_call_clean_up;
+            }
+
+            if (isArray) {
+                if (!XPCConvert::NativeArray2JS(&val,
+                                                (const void**)&pv->val,
+                                                datum_type, &param_iid,
+                                                array_count, nullptr))
+                    goto pre_call_clean_up;
+            } else if (isSizedString) {
+                if (!XPCConvert::NativeStringWithSize2JS(&val,
+                                                         (const void*)&pv->val,
+                                                         datum_type,
+                                                         array_count, nullptr))
+                    goto pre_call_clean_up;
+            } else {
+                if (!XPCConvert::NativeData2JS(&val, &pv->val, type,
+                                               &param_iid, nullptr))
+                    goto pre_call_clean_up;
+            }
+        }
+
+        if (param.IsOut() || param.IsDipper()) {
+            // create an 'out' object
+            RootedObject out_obj(cx, NewOutObject(cx));
+            if (!out_obj) {
+                retval = NS_ERROR_OUT_OF_MEMORY;
+                goto pre_call_clean_up;
+            }
+
+            if (param.IsIn()) {
+                if (!JS_SetPropertyById(cx, out_obj,
+                                        mContext->GetStringID(XPCJSContext::IDX_VALUE),
+                                        val)) {
+                    goto pre_call_clean_up;
+                }
+            }
+            *sp++ = JS::ObjectValue(*out_obj);
+        } else
+            *sp++ = val;
+    }
+
+    readyToDoTheCall = true;
+
+pre_call_clean_up:
+    // clean up any 'out' params handed in
+    CleanupOutparams(cx, methodIndex, info, nativeParams, /* inOutOnly = */ true, paramCount);
+
+    // Make sure "this" doesn't get deleted during this call.
+    nsCOMPtr<nsIXPCWrappedJSClass> kungFuDeathGrip(this);
+
+    if (!readyToDoTheCall)
+        return retval;
+
+    // do the deed - note exceptions
+
+    MOZ_ASSERT(!aes.HasException());
+
+    nsCOMPtr<nsIException> syntheticException;
+    RootedValue rval(cx);
+    if (XPT_MD_IS_GETTER(info->flags)) {
+        success = JS_GetProperty(cx, obj, name, &rval);
+    } else if (XPT_MD_IS_SETTER(info->flags)) {
+        rval = *argv;
+        success = JS_SetProperty(cx, obj, name, rval);
+    } else {
+        if (!fval.isPrimitive()) {
+            success = JS_CallFunctionValue(cx, thisObj, fval, args, &rval);
+        } else {
+            // The property was not an object so can't be a function.
+            // Let's build and 'throw' an exception.
+
+            static const nsresult code =
+                    NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED;
+            static const char format[] = "%s \"%s\"";
+            const char * msg;
+            char* sz = nullptr;
+
+            if (nsXPCException::NameAndFormatForNSResult(code, nullptr, &msg) && msg)
+                sz = JS_smprintf(format, msg, name);
+
+            XPCConvert::ConstructException(code, sz, GetInterfaceName(), name,
+                                           nullptr, getter_AddRefs(syntheticException),
+                                           nullptr, nullptr);
+            if (sz)
+                JS_smprintf_free(sz);
+            success = false;
+        }
+    }
+
+    if (!success)
+        return CheckForException(ccx, aes, name, GetInterfaceName(),
+                                 syntheticException);
+
+    XPCJSContext::Get()->SetPendingException(nullptr); // XXX necessary?
+
+    // convert out args and result
+    // NOTE: this is the total number of native params, not just the args
+    // Convert independent params only.
+    // When we later convert the dependent params (if any) we will know that
+    // the params upon which they depend will have already been converted -
+    // regardless of ordering.
+
+    foundDependentParam = false;
+    for (i = 0; i < paramCount; i++) {
+        const nsXPTParamInfo& param = info->params[i];
+        MOZ_ASSERT(!param.IsShared(), "[shared] implies [noscript]!");
+        if (!param.IsOut() && !param.IsDipper())
+            continue;
+
+        const nsXPTType& type = param.GetType();
+        if (type.IsDependent()) {
+            foundDependentParam = true;
+            continue;
+        }
+
+        RootedValue val(cx);
+        uint8_t type_tag = type.TagPart();
+        nsXPTCMiniVariant* pv;
+
+        if (param.IsDipper())
+            pv = (nsXPTCMiniVariant*) &nativeParams[i].val.p;
+        else
+            pv = (nsXPTCMiniVariant*) nativeParams[i].val.p;
+
+        if (param.IsRetval())
+            val = rval;
+        else if (argv[i].isPrimitive())
+            break;
+        else {
+            RootedObject obj(cx, &argv[i].toObject());
+            if (!JS_GetPropertyById(cx, obj,
+                                    mContext->GetStringID(XPCJSContext::IDX_VALUE),
+                                    &val))
+                break;
+        }
+
+        // setup allocator and/or iid
+
+        if (type_tag == nsXPTType::T_INTERFACE) {
+            if (NS_FAILED(GetInterfaceInfo()->
+                          GetIIDForParamNoAlloc(methodIndex, &param,
+                                                &param_iid)))
+                break;
+        }
+
+        if (!XPCConvert::JSData2Native(&pv->val, val, type,
+                                       &param_iid, nullptr))
+            break;
+    }
+
+    // if any params were dependent, then we must iterate again to convert them.
+    if (foundDependentParam && i == paramCount) {
+        for (i = 0; i < paramCount; i++) {
+            const nsXPTParamInfo& param = info->params[i];
+            if (!param.IsOut())
+                continue;
+
+            const nsXPTType& type = param.GetType();
+            if (!type.IsDependent())
+                continue;
+
+            RootedValue val(cx);
+            nsXPTCMiniVariant* pv;
+            nsXPTType datum_type;
+            uint32_t array_count;
+            bool isArray = type.IsArray();
+            bool isSizedString = isArray ?
+                    false :
+                    type.TagPart() == nsXPTType::T_PSTRING_SIZE_IS ||
+                    type.TagPart() == nsXPTType::T_PWSTRING_SIZE_IS;
+
+            pv = (nsXPTCMiniVariant*) nativeParams[i].val.p;
+
+            if (param.IsRetval())
+                val = rval;
+            else {
+                RootedObject obj(cx, &argv[i].toObject());
+                if (!JS_GetPropertyById(cx, obj,
+                                        mContext->GetStringID(XPCJSContext::IDX_VALUE),
+                                        &val))
+                    break;
+            }
+
+            // setup allocator and/or iid
+
+            if (isArray) {
+                if (NS_FAILED(mInfo->GetTypeForParam(methodIndex, &param, 1,
+                                                     &datum_type)))
+                    break;
+            } else
+                datum_type = type;
+
+            if (datum_type.IsInterfacePointer()) {
+               if (!GetInterfaceTypeFromParam(cx, info, param, methodIndex,
+                                              datum_type, nativeParams,
+                                              &param_iid))
+                   break;
+            }
+
+            if (isArray || isSizedString) {
+                if (!GetArraySizeFromParam(cx, info, param, methodIndex,
+                                           i, nativeParams, &array_count))
+                    break;
+            }
+
+            if (isArray) {
+                if (array_count &&
+                    !XPCConvert::JSArray2Native((void**)&pv->val, val,
+                                                array_count, datum_type,
+                                                &param_iid, nullptr))
+                    break;
+            } else if (isSizedString) {
+                if (!XPCConvert::JSStringWithSize2Native((void*)&pv->val, val,
+                                                         array_count, datum_type,
+                                                         nullptr))
+                    break;
+            } else {
+                if (!XPCConvert::JSData2Native(&pv->val, val, type,
+                                               &param_iid,
+                                               nullptr))
+                    break;
+            }
+        }
+    }
+
+    if (i != paramCount) {
+        // We didn't manage all the result conversions!
+        // We have to cleanup any junk that *did* get converted.
+        CleanupOutparams(cx, methodIndex, info, nativeParams, /* inOutOnly = */ false, i);
+    } else {
+        // set to whatever the JS code might have set as the result
+        retval = xpccx->GetPendingResult();
+    }
+
+    return retval;
+}
+
+const char*
+nsXPCWrappedJSClass::GetInterfaceName()
+{
+    if (!mName)
+        mInfo->GetName(&mName);
+    return mName;
+}
+
+static const JSClass XPCOutParamClass = {
+    "XPCOutParam",
+    0,
+    JS_NULL_CLASS_OPS
+};
+
+bool
+xpc::IsOutObject(JSContext* cx, JSObject* obj)
+{
+    return js::GetObjectJSClass(obj) == &XPCOutParamClass;
+}
+
+JSObject*
+xpc::NewOutObject(JSContext* cx)
+{
+    return JS_NewObject(cx, &XPCOutParamClass);
+}
+
+
+NS_IMETHODIMP
+nsXPCWrappedJSClass::DebugDump(int16_t depth)
+{
+#ifdef DEBUG
+    depth-- ;
+    XPC_LOG_ALWAYS(("nsXPCWrappedJSClass @ %x with mRefCnt = %d", this, mRefCnt.get()));
+    XPC_LOG_INDENT();
+        char* name;
+        mInfo->GetName(&name);
+        XPC_LOG_ALWAYS(("interface name is %s", name));
+        if (name)
+            free(name);
+        char * iid = mIID.ToString();
+        XPC_LOG_ALWAYS(("IID number is %s", iid ? iid : "invalid"));
+        if (iid)
+            free(iid);
+        XPC_LOG_ALWAYS(("InterfaceInfo @ %x", mInfo.get()));
+        uint16_t methodCount = 0;
+        if (depth) {
+            uint16_t i;
+            nsCOMPtr<nsIInterfaceInfo> parent;
+            XPC_LOG_INDENT();
+            mInfo->GetParent(getter_AddRefs(parent));
+            XPC_LOG_ALWAYS(("parent @ %x", parent.get()));
+            mInfo->GetMethodCount(&methodCount);
+            XPC_LOG_ALWAYS(("MethodCount = %d", methodCount));
+            mInfo->GetConstantCount(&i);
+            XPC_LOG_ALWAYS(("ConstantCount = %d", i));
+            XPC_LOG_OUTDENT();
+        }
+        XPC_LOG_ALWAYS(("mContext @ %x", mContext));
+        XPC_LOG_ALWAYS(("mDescriptors @ %x count = %d", mDescriptors, methodCount));
+        if (depth && mDescriptors && methodCount) {
+            depth--;
+            XPC_LOG_INDENT();
+            for (uint16_t i = 0; i < methodCount; i++) {
+                XPC_LOG_ALWAYS(("Method %d is %s%s", \
+                                i, IsReflectable(i) ? "":" NOT ","reflectable"));
+            }
+            XPC_LOG_OUTDENT();
+            depth++;
+        }
+    XPC_LOG_OUTDENT();
+#endif
+    return NS_OK;
+}
diff --git a/js/xpconnect/src/XPCWrappedNative.cpp b/js/xpconnect/src/XPCWrappedNative.cpp
new file mode 100644
index 000000000..acf92f3c3
--- /dev/null
+++ b/js/xpconnect/src/XPCWrappedNative.cpp
@@ -0,0 +1,2325 @@
+/* -*- 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/. */
+
+/* Wrapper object for reflecting native xpcom objects into JavaScript. */
+
+#include "xpcprivate.h"
+#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
+#include "nsWrapperCacheInlines.h"
+#include "XPCLog.h"
+#include "jsprf.h"
+#include "jsfriendapi.h"
+#include "AccessCheck.h"
+#include "WrapperFactory.h"
+#include "XrayWrapper.h"
+
+#include "nsContentUtils.h"
+#include "nsCycleCollectionNoteRootCallback.h"
+
+#include <stdint.h>
+#include "mozilla/DeferredFinalize.h"
+#include "mozilla/Likely.h"
+#include "mozilla/Unused.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/dom/BindingUtils.h"
+#include <algorithm>
+
+using namespace xpc;
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace JS;
+
+/***************************************************************************/
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(XPCWrappedNative)
+
+// No need to unlink the JS objects: if the XPCWrappedNative is cycle
+// collected then its mFlatJSObject will be cycle collected too and
+// finalization of the mFlatJSObject will unlink the JS objects (see
+// XPC_WN_NoHelper_Finalize and FlatJSObjectFinalized).
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(XPCWrappedNative)
+    tmp->ExpireWrapper();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(XPCWrappedNative)
+    if (!tmp->IsValid())
+        return NS_OK;
+
+    if (MOZ_UNLIKELY(cb.WantDebugInfo())) {
+        char name[72];
+        XPCNativeScriptableInfo* si = tmp->GetScriptableInfo();
+        if (si)
+            SprintfLiteral(name, "XPCWrappedNative (%s)", si->GetJSClass()->name);
+        else
+            SprintfLiteral(name, "XPCWrappedNative");
+
+        cb.DescribeRefCountedNode(tmp->mRefCnt.get(), name);
+    } else {
+        NS_IMPL_CYCLE_COLLECTION_DESCRIBE(XPCWrappedNative, tmp->mRefCnt.get())
+    }
+
+    if (tmp->HasExternalReference()) {
+
+        // If our refcount is > 1, our reference to the flat JS object is
+        // considered "strong", and we're going to traverse it.
+        //
+        // If our refcount is <= 1, our reference to the flat JS object is
+        // considered "weak", and we're *not* going to traverse it.
+        //
+        // This reasoning is in line with the slightly confusing lifecycle rules
+        // for XPCWrappedNatives, described in a larger comment below and also
+        // on our wiki at http://wiki.mozilla.org/XPConnect_object_wrapping
+
+        JSObject* obj = tmp->GetFlatJSObjectPreserveColor();
+        NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mFlatJSObject");
+        cb.NoteJSChild(JS::GCCellPtr(obj));
+    }
+
+    // XPCWrappedNative keeps its native object alive.
+    NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mIdentity");
+    cb.NoteXPCOMChild(tmp->GetIdentityObject());
+
+    tmp->NoteTearoffs(cb);
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+void
+XPCWrappedNative::Suspect(nsCycleCollectionNoteRootCallback& cb)
+{
+    if (!IsValid() || IsWrapperExpired())
+        return;
+
+    MOZ_ASSERT(NS_IsMainThread(),
+               "Suspecting wrapped natives from non-main thread");
+
+    // Only record objects that might be part of a cycle as roots, unless
+    // the callback wants all traces (a debug feature). Do this even if
+    // the XPCWN doesn't own the JS reflector object in case the reflector
+    // keeps alive other C++ things. This is safe because if the reflector
+    // had died the reference from the XPCWN to it would have been cleared.
+    JSObject* obj = GetFlatJSObjectPreserveColor();
+    if (JS::ObjectIsMarkedGray(obj) || cb.WantAllTraces())
+        cb.NoteJSRoot(obj);
+}
+
+void
+XPCWrappedNative::NoteTearoffs(nsCycleCollectionTraversalCallback& cb)
+{
+    // Tearoffs hold their native object alive. If their JS object hasn't been
+    // finalized yet we'll note the edge between the JS object and the native
+    // (see nsXPConnect::Traverse), but if their JS object has been finalized
+    // then the tearoff is only reachable through the XPCWrappedNative, so we
+    // record an edge here.
+    for (XPCWrappedNativeTearOff* to = &mFirstTearOff; to; to = to->GetNextTearOff()) {
+        JSObject* jso = to->GetJSObjectPreserveColor();
+        if (!jso) {
+            NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "tearoff's mNative");
+            cb.NoteXPCOMChild(to->GetNative());
+        }
+    }
+}
+
+#ifdef XPC_CHECK_CLASSINFO_CLAIMS
+static void DEBUG_CheckClassInfoClaims(XPCWrappedNative* wrapper);
+#else
+#define DEBUG_CheckClassInfoClaims(wrapper) ((void)0)
+#endif
+
+/***************************************************************************/
+static nsresult
+FinishCreate(XPCWrappedNativeScope* Scope,
+             XPCNativeInterface* Interface,
+             nsWrapperCache* cache,
+             XPCWrappedNative* inWrapper,
+             XPCWrappedNative** resultWrapper);
+
+// static
+//
+// This method handles the special case of wrapping a new global object.
+//
+// The normal code path for wrapping natives goes through
+// XPCConvert::NativeInterface2JSObject, XPCWrappedNative::GetNewOrUsed,
+// and finally into XPCWrappedNative::Init. Unfortunately, this path assumes
+// very early on that we have an XPCWrappedNativeScope and corresponding global
+// JS object, which are the very things we need to create here. So we special-
+// case the logic and do some things in a different order.
+nsresult
+XPCWrappedNative::WrapNewGlobal(xpcObjectHelper& nativeHelper,
+                                nsIPrincipal* principal,
+                                bool initStandardClasses,
+                                JS::CompartmentOptions& aOptions,
+                                XPCWrappedNative** wrappedGlobal)
+{
+    AutoJSContext cx;
+    nsISupports* identity = nativeHelper.GetCanonical();
+
+    // The object should specify that it's meant to be global.
+    MOZ_ASSERT(nativeHelper.GetScriptableFlags() & nsIXPCScriptable::IS_GLOBAL_OBJECT);
+
+    // We shouldn't be reusing globals.
+    MOZ_ASSERT(!nativeHelper.GetWrapperCache() ||
+               !nativeHelper.GetWrapperCache()->GetWrapperPreserveColor());
+
+    // Put together the ScriptableCreateInfo...
+    XPCNativeScriptableCreateInfo sciProto;
+    XPCNativeScriptableCreateInfo sciMaybe;
+    const XPCNativeScriptableCreateInfo& sciWrapper =
+        GatherScriptableCreateInfo(identity, nativeHelper.GetClassInfo(),
+                                   sciProto, sciMaybe);
+
+    // ...and then ScriptableInfo. We need all this stuff now because it's going
+    // to tell us the JSClass of the object we're going to create.
+    XPCNativeScriptableInfo* si = XPCNativeScriptableInfo::Construct(&sciWrapper);
+    MOZ_ASSERT(si);
+
+    // Finally, we get to the JSClass.
+    const JSClass* clasp = si->GetJSClass();
+    MOZ_ASSERT(clasp->flags & JSCLASS_IS_GLOBAL);
+
+    // Create the global.
+    aOptions.creationOptions().setTrace(XPCWrappedNative::Trace);
+    if (xpc::SharedMemoryEnabled())
+        aOptions.creationOptions().setSharedMemoryAndAtomicsEnabled(true);
+    RootedObject global(cx, xpc::CreateGlobalObject(cx, clasp, principal, aOptions));
+    if (!global)
+        return NS_ERROR_FAILURE;
+    XPCWrappedNativeScope* scope = CompartmentPrivate::Get(global)->scope;
+
+    // Immediately enter the global's compartment, so that everything else we
+    // create ends up there.
+    JSAutoCompartment ac(cx, global);
+
+    // If requested, initialize the standard classes on the global.
+    if (initStandardClasses && ! JS_InitStandardClasses(cx, global))
+        return NS_ERROR_FAILURE;
+
+    // Make a proto.
+    XPCWrappedNativeProto* proto =
+        XPCWrappedNativeProto::GetNewOrUsed(scope,
+                                            nativeHelper.GetClassInfo(), &sciProto,
+                                            /* callPostCreatePrototype = */ false);
+    if (!proto)
+        return NS_ERROR_FAILURE;
+
+    // Set up the prototype on the global.
+    MOZ_ASSERT(proto->GetJSProtoObject());
+    RootedObject protoObj(cx, proto->GetJSProtoObject());
+    bool success = JS_SplicePrototype(cx, global, protoObj);
+    if (!success)
+        return NS_ERROR_FAILURE;
+
+    // Construct the wrapper, which takes over the strong reference to the
+    // native object.
+    RefPtr<XPCWrappedNative> wrapper =
+        new XPCWrappedNative(nativeHelper.forgetCanonical(), proto);
+
+    //
+    // We don't call ::Init() on this wrapper, because our setup requirements
+    // are different for globals. We do our setup inline here, instead.
+    //
+
+    // Share mScriptableInfo with the proto.
+    //
+    // This is probably more trouble than it's worth, since we've already
+    // created an XPCNativeScriptableInfo for ourselves. Nevertheless, this is
+    // what ::Init() does, and we want to be as consistent as possible with
+    // that code.
+    XPCNativeScriptableInfo* siProto = proto->GetScriptableInfo();
+    if (siProto && siProto->GetCallback() == sciWrapper.GetCallback()) {
+        wrapper->mScriptableInfo = siProto;
+        // XPCNativeScriptableInfo uses manual memory management. If we're
+        // switching over to that of the proto, we need to destroy the one
+        // we've allocated.
+        delete si;
+        si = nullptr;
+    } else {
+        wrapper->mScriptableInfo = si;
+    }
+
+    // Set the JS object to the global we already created.
+    wrapper->mFlatJSObject = global;
+    wrapper->mFlatJSObject.setFlags(FLAT_JS_OBJECT_VALID);
+
+    // Set the private to the XPCWrappedNative.
+    JS_SetPrivate(global, wrapper);
+
+    // There are dire comments elsewhere in the code about how a GC can
+    // happen somewhere after wrapper initialization but before the wrapper is
+    // added to the hashtable in FinishCreate(). It's not clear if that can
+    // happen here, but let's just be safe for now.
+    AutoMarkingWrappedNativePtr wrapperMarker(cx, wrapper);
+
+    // Call the common Init finish routine. This mainly just does an AddRef
+    // on behalf of XPConnect (the corresponding Release is in the finalizer
+    // hook), but it does some other miscellaneous things too, so we don't
+    // inline it.
+    success = wrapper->FinishInit();
+    MOZ_ASSERT(success);
+
+    // Go through some extra work to find the tearoff. This is kind of silly
+    // on a conceptual level: the point of tearoffs is to cache the results
+    // of QI-ing mIdentity to different interfaces, and we don't need that
+    // since we're dealing with nsISupports. But lots of code expects tearoffs
+    // to exist for everything, so we just follow along.
+    RefPtr<XPCNativeInterface> iface = XPCNativeInterface::GetNewOrUsed(&NS_GET_IID(nsISupports));
+    MOZ_ASSERT(iface);
+    nsresult status;
+    success = wrapper->FindTearOff(iface, false, &status);
+    if (!success)
+        return status;
+
+    // Call the common creation finish routine. This does all of the bookkeeping
+    // like inserting the wrapper into the wrapper map and setting up the wrapper
+    // cache.
+    nsresult rv = FinishCreate(scope, iface, nativeHelper.GetWrapperCache(),
+                               wrapper, wrappedGlobal);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+}
+
+// static
+nsresult
+XPCWrappedNative::GetNewOrUsed(xpcObjectHelper& helper,
+                               XPCWrappedNativeScope* Scope,
+                               XPCNativeInterface* Interface,
+                               XPCWrappedNative** resultWrapper)
+{
+    MOZ_ASSERT(Interface);
+    AutoJSContext cx;
+    nsWrapperCache* cache = helper.GetWrapperCache();
+
+    MOZ_ASSERT(!cache || !cache->GetWrapperPreserveColor(),
+               "We assume the caller already checked if it could get the "
+               "wrapper from the cache.");
+
+    nsresult rv;
+
+    MOZ_ASSERT(!Scope->GetContext()->GCIsRunning(),
+               "XPCWrappedNative::GetNewOrUsed called during GC");
+
+    nsISupports* identity = helper.GetCanonical();
+
+    if (!identity) {
+        NS_ERROR("This XPCOM object fails in QueryInterface to nsISupports!");
+        return NS_ERROR_FAILURE;
+    }
+
+    RefPtr<XPCWrappedNative> wrapper;
+
+    Native2WrappedNativeMap* map = Scope->GetWrappedNativeMap();
+    // Some things are nsWrapperCache subclasses but never use the cache, so go
+    // ahead and check our map even if we have a cache and it has no existing
+    // wrapper: we might have an XPCWrappedNative anyway.
+    wrapper = map->Find(identity);
+
+    if (wrapper) {
+        if (!wrapper->FindTearOff(Interface, false, &rv)) {
+            MOZ_ASSERT(NS_FAILED(rv), "returning NS_OK on failure");
+            return rv;
+        }
+        wrapper.forget(resultWrapper);
+        return NS_OK;
+    }
+
+    // There is a chance that the object wants to have the self-same JSObject
+    // reflection regardless of the scope into which we are reflecting it.
+    // Many DOM objects require this. The scriptable helper specifies this
+    // in preCreate by indicating a 'parent' of a particular scope.
+    //
+    // To handle this we need to get the scriptable helper early and ask it.
+    // It is possible that we will then end up forwarding this entire call
+    // to this same function but with a different scope.
+
+    // If we are making a wrapper for an nsIClassInfo singleton then
+    // We *don't* want to have it use the prototype meant for instances
+    // of that class.
+    uint32_t classInfoFlags;
+    bool isClassInfoSingleton = helper.GetClassInfo() == helper.Object() &&
+                                NS_SUCCEEDED(helper.GetClassInfo()
+                                                   ->GetFlags(&classInfoFlags)) &&
+                                (classInfoFlags & nsIClassInfo::SINGLETON_CLASSINFO);
+
+    nsIClassInfo* info = helper.GetClassInfo();
+
+    XPCNativeScriptableCreateInfo sciProto;
+    XPCNativeScriptableCreateInfo sci;
+
+    // Gather scriptable create info if we are wrapping something
+    // other than an nsIClassInfo object. We need to not do this for
+    // nsIClassInfo objects because often nsIClassInfo implementations
+    // are also nsIXPCScriptable helper implementations, but the helper
+    // code is obviously intended for the implementation of the class
+    // described by the nsIClassInfo, not for the class info object
+    // itself.
+    const XPCNativeScriptableCreateInfo& sciWrapper =
+        isClassInfoSingleton ? sci :
+        GatherScriptableCreateInfo(identity, info, sciProto, sci);
+
+    RootedObject parent(cx, Scope->GetGlobalJSObject());
+
+    mozilla::Maybe<JSAutoCompartment> ac;
+
+    if (sciWrapper.GetFlags().WantPreCreate()) {
+        RootedObject plannedParent(cx, parent);
+        nsresult rv = sciWrapper.GetCallback()->PreCreate(identity, cx,
+                                                          parent, parent.address());
+        if (NS_FAILED(rv))
+            return rv;
+        rv = NS_OK;
+
+        MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(parent),
+                   "Xray wrapper being used to parent XPCWrappedNative?");
+
+        MOZ_ASSERT(js::GetGlobalForObjectCrossCompartment(parent) == parent,
+                   "Non-global being used to parent XPCWrappedNative?");
+
+        ac.emplace(static_cast<JSContext*>(cx), parent);
+
+        if (parent != plannedParent) {
+            XPCWrappedNativeScope* betterScope = ObjectScope(parent);
+            MOZ_ASSERT(betterScope != Scope,
+                       "How can we have the same scope for two different globals?");
+            return GetNewOrUsed(helper, betterScope, Interface, resultWrapper);
+        }
+
+        // Take the performance hit of checking the hashtable again in case
+        // the preCreate call caused the wrapper to get created through some
+        // interesting path (the DOM code tends to make this happen sometimes).
+
+        if (cache) {
+            RootedObject cached(cx, cache->GetWrapper());
+            if (cached)
+                wrapper = XPCWrappedNative::Get(cached);
+        } else {
+            wrapper = map->Find(identity);
+        }
+
+        if (wrapper) {
+            if (wrapper->FindTearOff(Interface, false, &rv)) {
+                MOZ_ASSERT(NS_FAILED(rv), "returning NS_OK on failure");
+                return rv;
+            }
+            wrapper.forget(resultWrapper);
+            return NS_OK;
+        }
+    } else {
+        ac.emplace(static_cast<JSContext*>(cx), parent);
+    }
+
+    AutoMarkingWrappedNativeProtoPtr proto(cx);
+
+    // If there is ClassInfo (and we are not building a wrapper for the
+    // nsIClassInfo interface) then we use a wrapper that needs a prototype.
+
+    // Note that the security check happens inside FindTearOff - after the
+    // wrapper is actually created, but before JS code can see it.
+
+    if (info && !isClassInfoSingleton) {
+        proto = XPCWrappedNativeProto::GetNewOrUsed(Scope, info, &sciProto);
+        if (!proto)
+            return NS_ERROR_FAILURE;
+
+        wrapper = new XPCWrappedNative(helper.forgetCanonical(), proto);
+    } else {
+        RefPtr<XPCNativeInterface> iface = Interface;
+        if (!iface)
+            iface = XPCNativeInterface::GetISupports();
+
+        XPCNativeSetKey key(iface);
+        RefPtr<XPCNativeSet> set =
+            XPCNativeSet::GetNewOrUsed(&key);
+
+        if (!set)
+            return NS_ERROR_FAILURE;
+
+        wrapper = new XPCWrappedNative(helper.forgetCanonical(), Scope,
+                                       set.forget());
+    }
+
+    MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(parent),
+               "Xray wrapper being used to parent XPCWrappedNative?");
+
+    // We use an AutoMarkingPtr here because it is possible for JS gc to happen
+    // after we have Init'd the wrapper but *before* we add it to the hashtable.
+    // This would cause the mSet to get collected and we'd later crash. I've
+    // *seen* this happen.
+    AutoMarkingWrappedNativePtr wrapperMarker(cx, wrapper);
+
+    if (!wrapper->Init(&sciWrapper))
+        return NS_ERROR_FAILURE;
+
+    if (!wrapper->FindTearOff(Interface, false, &rv)) {
+        MOZ_ASSERT(NS_FAILED(rv), "returning NS_OK on failure");
+        return rv;
+    }
+
+    return FinishCreate(Scope, Interface, cache, wrapper, resultWrapper);
+}
+
+static nsresult
+FinishCreate(XPCWrappedNativeScope* Scope,
+             XPCNativeInterface* Interface,
+             nsWrapperCache* cache,
+             XPCWrappedNative* inWrapper,
+             XPCWrappedNative** resultWrapper)
+{
+    AutoJSContext cx;
+    MOZ_ASSERT(inWrapper);
+
+    Native2WrappedNativeMap* map = Scope->GetWrappedNativeMap();
+
+    RefPtr<XPCWrappedNative> wrapper;
+    // Deal with the case where the wrapper got created as a side effect
+    // of one of our calls out of this code. Add() returns the (possibly
+    // pre-existing) wrapper that ultimately ends up in the map, which is
+    // what we want.
+    wrapper = map->Add(inWrapper);
+    if (!wrapper)
+        return NS_ERROR_FAILURE;
+
+    if (wrapper == inWrapper) {
+        JSObject* flat = wrapper->GetFlatJSObject();
+        MOZ_ASSERT(!cache || !cache->GetWrapperPreserveColor() ||
+                   flat == cache->GetWrapperPreserveColor(),
+                   "This object has a cached wrapper that's different from "
+                   "the JSObject held by its native wrapper?");
+
+        if (cache && !cache->GetWrapperPreserveColor())
+            cache->SetWrapper(flat);
+    }
+
+    DEBUG_CheckClassInfoClaims(wrapper);
+    wrapper.forget(resultWrapper);
+    return NS_OK;
+}
+
+// static
+nsresult
+XPCWrappedNative::GetUsedOnly(nsISupports* Object,
+                              XPCWrappedNativeScope* Scope,
+                              XPCNativeInterface* Interface,
+                              XPCWrappedNative** resultWrapper)
+{
+    AutoJSContext cx;
+    MOZ_ASSERT(Object, "XPCWrappedNative::GetUsedOnly was called with a null Object");
+    MOZ_ASSERT(Interface);
+
+    RefPtr<XPCWrappedNative> wrapper;
+    nsWrapperCache* cache = nullptr;
+    CallQueryInterface(Object, &cache);
+    if (cache) {
+        RootedObject flat(cx, cache->GetWrapper());
+        if (!flat) {
+            *resultWrapper = nullptr;
+            return NS_OK;
+        }
+        wrapper = XPCWrappedNative::Get(flat);
+    } else {
+        nsCOMPtr<nsISupports> identity = do_QueryInterface(Object);
+
+        if (!identity) {
+            NS_ERROR("This XPCOM object fails in QueryInterface to nsISupports!");
+            return NS_ERROR_FAILURE;
+        }
+
+        Native2WrappedNativeMap* map = Scope->GetWrappedNativeMap();
+
+        wrapper = map->Find(identity);
+        if (!wrapper) {
+            *resultWrapper = nullptr;
+            return NS_OK;
+        }
+    }
+
+    nsresult rv;
+    if (!wrapper->FindTearOff(Interface, false, &rv)) {
+        MOZ_ASSERT(NS_FAILED(rv), "returning NS_OK on failure");
+        return rv;
+    }
+
+    wrapper.forget(resultWrapper);
+    return NS_OK;
+}
+
+// This ctor is used if this object will have a proto.
+XPCWrappedNative::XPCWrappedNative(already_AddRefed<nsISupports>&& aIdentity,
+                                   XPCWrappedNativeProto* aProto)
+    : mMaybeProto(aProto),
+      mSet(aProto->GetSet()),
+      mScriptableInfo(nullptr)
+{
+    MOZ_ASSERT(NS_IsMainThread());
+
+    mIdentity = aIdentity;
+    mFlatJSObject.setFlags(FLAT_JS_OBJECT_VALID);
+
+    MOZ_ASSERT(mMaybeProto, "bad ctor param");
+    MOZ_ASSERT(mSet, "bad ctor param");
+}
+
+// This ctor is used if this object will NOT have a proto.
+XPCWrappedNative::XPCWrappedNative(already_AddRefed<nsISupports>&& aIdentity,
+                                   XPCWrappedNativeScope* aScope,
+                                   already_AddRefed<XPCNativeSet>&& aSet)
+
+    : mMaybeScope(TagScope(aScope)),
+      mSet(aSet),
+      mScriptableInfo(nullptr)
+{
+    MOZ_ASSERT(NS_IsMainThread());
+
+    mIdentity = aIdentity;
+    mFlatJSObject.setFlags(FLAT_JS_OBJECT_VALID);
+
+    MOZ_ASSERT(aScope, "bad ctor param");
+    MOZ_ASSERT(mSet, "bad ctor param");
+}
+
+XPCWrappedNative::~XPCWrappedNative()
+{
+    Destroy();
+}
+
+void
+XPCWrappedNative::Destroy()
+{
+    XPCWrappedNativeProto* proto = GetProto();
+
+    if (mScriptableInfo &&
+        (!HasProto() ||
+         (proto && proto->GetScriptableInfo() != mScriptableInfo))) {
+        delete mScriptableInfo;
+        mScriptableInfo = nullptr;
+    }
+
+    XPCWrappedNativeScope* scope = GetScope();
+    if (scope) {
+        Native2WrappedNativeMap* map = scope->GetWrappedNativeMap();
+
+        // Post-1.9 we should not remove this wrapper from the map if it is
+        // uninitialized.
+        map->Remove(this);
+    }
+
+    if (mIdentity) {
+        XPCJSContext* cx = GetContext();
+        if (cx && cx->GetDoingFinalization()) {
+            DeferredFinalize(mIdentity.forget().take());
+        } else {
+            mIdentity = nullptr;
+        }
+    }
+
+    mMaybeScope = nullptr;
+}
+
+void
+XPCWrappedNative::UpdateScriptableInfo(XPCNativeScriptableInfo* si)
+{
+    MOZ_ASSERT(mScriptableInfo, "UpdateScriptableInfo expects an existing scriptable info");
+    mScriptableInfo = si;
+}
+
+void
+XPCWrappedNative::SetProto(XPCWrappedNativeProto* p)
+{
+    MOZ_ASSERT(!IsWrapperExpired(), "bad ptr!");
+
+    MOZ_ASSERT(HasProto());
+
+    // Write barrier for incremental GC.
+    JSContext* cx = GetContext()->Context();
+    GetProto()->WriteBarrierPre(cx);
+
+    mMaybeProto = p;
+}
+
+// This is factored out so that it can be called publicly
+// static
+void
+XPCWrappedNative::GatherProtoScriptableCreateInfo(nsIClassInfo* classInfo,
+                                                  XPCNativeScriptableCreateInfo& sciProto)
+{
+    MOZ_ASSERT(classInfo, "bad param");
+    MOZ_ASSERT(!sciProto.GetCallback(), "bad param");
+
+    nsXPCClassInfo* classInfoHelper = nullptr;
+    CallQueryInterface(classInfo, &classInfoHelper);
+    if (classInfoHelper) {
+        nsCOMPtr<nsIXPCScriptable> helper =
+          dont_AddRef(static_cast<nsIXPCScriptable*>(classInfoHelper));
+        uint32_t flags = classInfoHelper->GetScriptableFlags();
+        sciProto.SetCallback(helper.forget());
+        sciProto.SetFlags(XPCNativeScriptableFlags(flags));
+
+        return;
+    }
+
+    nsCOMPtr<nsIXPCScriptable> helper;
+    nsresult rv = classInfo->GetScriptableHelper(getter_AddRefs(helper));
+    if (NS_SUCCEEDED(rv) && helper) {
+        uint32_t flags = helper->GetScriptableFlags();
+        sciProto.SetCallback(helper.forget());
+        sciProto.SetFlags(XPCNativeScriptableFlags(flags));
+    }
+}
+
+// static
+const XPCNativeScriptableCreateInfo&
+XPCWrappedNative::GatherScriptableCreateInfo(nsISupports* obj,
+                                             nsIClassInfo* classInfo,
+                                             XPCNativeScriptableCreateInfo& sciProto,
+                                             XPCNativeScriptableCreateInfo& sciWrapper)
+{
+    MOZ_ASSERT(!sciWrapper.GetCallback(), "bad param");
+
+    // Get the class scriptable helper (if present)
+    if (classInfo) {
+        GatherProtoScriptableCreateInfo(classInfo, sciProto);
+
+        if (sciProto.GetFlags().DontAskInstanceForScriptable())
+            return sciProto;
+    }
+
+    // Do the same for the wrapper specific scriptable
+    nsCOMPtr<nsIXPCScriptable> helper(do_QueryInterface(obj));
+    if (helper) {
+        uint32_t flags = helper->GetScriptableFlags();
+        sciWrapper.SetCallback(helper.forget());
+        sciWrapper.SetFlags(XPCNativeScriptableFlags(flags));
+
+        // A whole series of assertions to catch bad uses of scriptable flags on
+        // the siWrapper...
+
+        MOZ_ASSERT(!(sciWrapper.GetFlags().WantPreCreate() &&
+                     !sciProto.GetFlags().WantPreCreate()),
+                   "Can't set WANT_PRECREATE on an instance scriptable "
+                   "without also setting it on the class scriptable");
+
+        MOZ_ASSERT(!(sciWrapper.GetFlags().DontEnumQueryInterface() &&
+                     !sciProto.GetFlags().DontEnumQueryInterface() &&
+                     sciProto.GetCallback()),
+                   "Can't set DONT_ENUM_QUERY_INTERFACE on an instance scriptable "
+                   "without also setting it on the class scriptable (if present and shared)");
+
+        MOZ_ASSERT(!(sciWrapper.GetFlags().DontAskInstanceForScriptable() &&
+                     !sciProto.GetFlags().DontAskInstanceForScriptable()),
+                   "Can't set DONT_ASK_INSTANCE_FOR_SCRIPTABLE on an instance scriptable "
+                   "without also setting it on the class scriptable");
+
+        MOZ_ASSERT(!(sciWrapper.GetFlags().ClassInfoInterfacesOnly() &&
+                     !sciProto.GetFlags().ClassInfoInterfacesOnly() &&
+                     sciProto.GetCallback()),
+                   "Can't set CLASSINFO_INTERFACES_ONLY on an instance scriptable "
+                   "without also setting it on the class scriptable (if present and shared)");
+
+        MOZ_ASSERT(!(sciWrapper.GetFlags().AllowPropModsDuringResolve() &&
+                     !sciProto.GetFlags().AllowPropModsDuringResolve() &&
+                     sciProto.GetCallback()),
+                   "Can't set ALLOW_PROP_MODS_DURING_RESOLVE on an instance scriptable "
+                   "without also setting it on the class scriptable (if present and shared)");
+
+        MOZ_ASSERT(!(sciWrapper.GetFlags().AllowPropModsToPrototype() &&
+                     !sciProto.GetFlags().AllowPropModsToPrototype() &&
+                     sciProto.GetCallback()),
+                   "Can't set ALLOW_PROP_MODS_TO_PROTOTYPE on an instance scriptable "
+                   "without also setting it on the class scriptable (if present and shared)");
+
+        return sciWrapper;
+    }
+
+    return sciProto;
+}
+
+bool
+XPCWrappedNative::Init(const XPCNativeScriptableCreateInfo* sci)
+{
+    AutoJSContext cx;
+    // setup our scriptable info...
+
+    if (sci->GetCallback()) {
+        if (HasProto()) {
+            XPCNativeScriptableInfo* siProto = GetProto()->GetScriptableInfo();
+            if (siProto && siProto->GetCallback() == sci->GetCallback())
+                mScriptableInfo = siProto;
+        }
+        if (!mScriptableInfo) {
+            mScriptableInfo = XPCNativeScriptableInfo::Construct(sci);
+
+            if (!mScriptableInfo)
+                return false;
+        }
+    }
+    XPCNativeScriptableInfo* si = mScriptableInfo;
+
+    // create our flatJSObject
+
+    const JSClass* jsclazz = si ? si->GetJSClass() : Jsvalify(&XPC_WN_NoHelper_JSClass);
+
+    // We should have the global jsclass flag if and only if we're a global.
+    MOZ_ASSERT_IF(si, !!si->GetFlags().IsGlobalObject() == !!(jsclazz->flags & JSCLASS_IS_GLOBAL));
+
+    MOZ_ASSERT(jsclazz &&
+               jsclazz->name &&
+               jsclazz->flags &&
+               jsclazz->getResolve() &&
+               jsclazz->hasFinalize(), "bad class");
+
+    // XXXbz JS_GetObjectPrototype wants an object, even though it then asserts
+    // that this object is same-compartment with cx, which means it could just
+    // use the cx global...
+    RootedObject global(cx, CurrentGlobalOrNull(cx));
+    RootedObject protoJSObject(cx, HasProto() ?
+                                   GetProto()->GetJSProtoObject() :
+                                   JS_GetObjectPrototype(cx, global));
+    if (!protoJSObject) {
+        return false;
+    }
+
+    mFlatJSObject = JS_NewObjectWithGivenProto(cx, jsclazz, protoJSObject);
+    if (!mFlatJSObject) {
+        mFlatJSObject.unsetFlags(FLAT_JS_OBJECT_VALID);
+        return false;
+    }
+
+    mFlatJSObject.setFlags(FLAT_JS_OBJECT_VALID);
+    JS_SetPrivate(mFlatJSObject, this);
+
+    return FinishInit();
+}
+
+bool
+XPCWrappedNative::FinishInit()
+{
+    AutoJSContext cx;
+
+    // This reference will be released when mFlatJSObject is finalized.
+    // Since this reference will push the refcount to 2 it will also root
+    // mFlatJSObject;
+    MOZ_ASSERT(1 == mRefCnt, "unexpected refcount value");
+    NS_ADDREF(this);
+
+    // A hack for bug 517665, increase the probability for GC.
+    JS_updateMallocCounter(cx, 2 * sizeof(XPCWrappedNative));
+
+    return true;
+}
+
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XPCWrappedNative)
+  NS_INTERFACE_MAP_ENTRY(nsIXPConnectWrappedNative)
+  NS_INTERFACE_MAP_ENTRY(nsIXPConnectJSObjectHolder)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXPConnectWrappedNative)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(XPCWrappedNative)
+
+// Release calls Destroy() immediately when the refcount drops to 0 to
+// clear the weak references nsXPConnect has to XPCWNs and to ensure there
+// are no pointers to dying protos.
+NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(XPCWrappedNative, Destroy())
+
+/*
+ *  Wrapped Native lifetime management is messy!
+ *
+ *  - At creation we push the refcount to 2 (only one of which is owned by
+ *    the native caller that caused the wrapper creation).
+ *  - During the JS GC Mark phase we mark any wrapper with a refcount > 1.
+ *  - The *only* thing that can make the wrapper get destroyed is the
+ *    finalization of mFlatJSObject. And *that* should only happen if the only
+ *    reference is the single extra (internal) reference we hold.
+ *
+ *  - The wrapper has a pointer to the nsISupports 'view' of the wrapped native
+ *    object i.e... mIdentity. This is held until the wrapper's refcount goes
+ *    to zero and the wrapper is released, or until an expired wrapper (i.e.,
+ *    one unlinked by the cycle collector) has had its JS object finalized.
+ *
+ *  - The wrapper also has 'tearoffs'. It has one tearoff for each interface
+ *    that is actually used on the native object. 'Used' means we have either
+ *    needed to QueryInterface to verify the availability of that interface
+ *    of that we've had to QueryInterface in order to actually make a call
+ *    into the wrapped object via the pointer for the given interface.
+ *
+ *  - Each tearoff's 'mNative' member (if non-null) indicates one reference
+ *    held by our wrapper on the wrapped native for the given interface
+ *    associated with the tearoff. If we release that reference then we set
+ *    the tearoff's 'mNative' to null.
+ *
+ *  - We use the occasion of the JavaScript GCCallback for the JSGC_MARK_END
+ *    event to scan the tearoffs of all wrappers for non-null mNative members
+ *    that represent unused references. We can tell that a given tearoff's
+ *    mNative is unused by noting that no live XPCCallContexts hold a pointer
+ *    to the tearoff.
+ *
+ *  - As a time/space tradeoff we may decide to not do this scanning on
+ *    *every* JavaScript GC. We *do* want to do this *sometimes* because
+ *    we want to allow for wrapped native's to do their own tearoff patterns.
+ *    So, we want to avoid holding references to interfaces that we don't need.
+ *    At the same time, we don't want to be bracketing every call into a
+ *    wrapped native object with a QueryInterface/Release pair. And we *never*
+ *    make a call into the object except via the correct interface for which
+ *    we've QI'd.
+ *
+ *  - Each tearoff *can* have a mJSObject whose lazily resolved properties
+ *    represent the methods/attributes/constants of that specific interface.
+ *    This is optionally reflected into JavaScript as "foo.nsIFoo" when "foo"
+ *    is the name of mFlatJSObject and "nsIFoo" is the name of the given
+ *    interface associated with the tearoff. When we create the tearoff's
+ *    mJSObject we set it's parent to be mFlatJSObject. This way we know that
+ *    when mFlatJSObject get's collected there are no outstanding reachable
+ *    tearoff mJSObjects. Note that we must clear the private of any lingering
+ *    mJSObjects at this point because we have no guarentee of the *order* of
+ *    finalization within a given gc cycle.
+ */
+
+void
+XPCWrappedNative::FlatJSObjectFinalized()
+{
+    if (!IsValid())
+        return;
+
+    // Iterate the tearoffs and null out each of their JSObject's privates.
+    // This will keep them from trying to access their pointers to the
+    // dying tearoff object. We can safely assume that those remaining
+    // JSObjects are about to be finalized too.
+
+    for (XPCWrappedNativeTearOff* to = &mFirstTearOff; to; to = to->GetNextTearOff()) {
+        JSObject* jso = to->GetJSObjectPreserveColor();
+        if (jso) {
+            JS_SetPrivate(jso, nullptr);
+#ifdef DEBUG
+            JS_UpdateWeakPointerAfterGCUnbarriered(&jso);
+            MOZ_ASSERT(!jso);
+#endif
+            to->JSObjectFinalized();
+        }
+
+        // We also need to release any native pointers held...
+        RefPtr<nsISupports> native = to->TakeNative();
+        if (native && GetContext()) {
+            DeferredFinalize(native.forget().take());
+        }
+
+        to->SetInterface(nullptr);
+    }
+
+    nsWrapperCache* cache = nullptr;
+    CallQueryInterface(mIdentity, &cache);
+    if (cache)
+        cache->ClearWrapper();
+
+    mFlatJSObject = nullptr;
+    mFlatJSObject.unsetFlags(FLAT_JS_OBJECT_VALID);
+
+    MOZ_ASSERT(mIdentity, "bad pointer!");
+#ifdef XP_WIN
+    // Try to detect free'd pointer
+    MOZ_ASSERT(*(int*)mIdentity.get() != 0xdddddddd, "bad pointer!");
+    MOZ_ASSERT(*(int*)mIdentity.get() != 0,          "bad pointer!");
+#endif
+
+    if (IsWrapperExpired()) {
+        Destroy();
+    }
+
+    // Note that it's not safe to touch mNativeWrapper here since it's
+    // likely that it has already been finalized.
+
+    Release();
+}
+
+void
+XPCWrappedNative::FlatJSObjectMoved(JSObject* obj, const JSObject* old)
+{
+    JS::AutoAssertGCCallback inCallback(obj);
+    MOZ_ASSERT(mFlatJSObject.unbarrieredGetPtr() == old);
+
+    nsWrapperCache* cache = nullptr;
+    CallQueryInterface(mIdentity, &cache);
+    if (cache)
+        cache->UpdateWrapper(obj, old);
+
+    mFlatJSObject = obj;
+}
+
+void
+XPCWrappedNative::SystemIsBeingShutDown()
+{
+    if (!IsValid())
+        return;
+
+    // The long standing strategy is to leak some objects still held at shutdown.
+    // The general problem is that propagating release out of xpconnect at
+    // shutdown time causes a world of problems.
+
+    // We leak mIdentity (see above).
+
+    // Short circuit future finalization.
+    JS_SetPrivate(mFlatJSObject, nullptr);
+    mFlatJSObject = nullptr;
+    mFlatJSObject.unsetFlags(FLAT_JS_OBJECT_VALID);
+
+    XPCWrappedNativeProto* proto = GetProto();
+
+    if (HasProto())
+        proto->SystemIsBeingShutDown();
+
+    // We don't destroy mScriptableInfo here. The destructor will do it.
+
+    // Cleanup the tearoffs.
+    for (XPCWrappedNativeTearOff* to = &mFirstTearOff; to; to = to->GetNextTearOff()) {
+        if (JSObject* jso = to->GetJSObjectPreserveColor()) {
+            JS_SetPrivate(jso, nullptr);
+            to->SetJSObject(nullptr);
+        }
+        // We leak the tearoff mNative
+        // (for the same reason we leak mIdentity - see above).
+        Unused << to->TakeNative().take();
+        to->SetInterface(nullptr);
+    }
+}
+
+/***************************************************************************/
+
+// Dynamically ensure that two objects don't end up with the same private.
+class MOZ_STACK_CLASS AutoClonePrivateGuard {
+public:
+    AutoClonePrivateGuard(JSContext* cx, JSObject* aOld, JSObject* aNew)
+        : mOldReflector(cx, aOld), mNewReflector(cx, aNew)
+    {
+        MOZ_ASSERT(JS_GetPrivate(aOld) == JS_GetPrivate(aNew));
+    }
+
+    ~AutoClonePrivateGuard()
+    {
+        if (JS_GetPrivate(mOldReflector)) {
+            JS_SetPrivate(mNewReflector, nullptr);
+        }
+    }
+
+private:
+    RootedObject mOldReflector;
+    RootedObject mNewReflector;
+};
+
+bool
+XPCWrappedNative::ExtendSet(XPCNativeInterface* aInterface)
+{
+    if (!mSet->HasInterface(aInterface)) {
+        XPCNativeSetKey key(mSet, aInterface);
+        RefPtr<XPCNativeSet> newSet =
+            XPCNativeSet::GetNewOrUsed(&key);
+        if (!newSet)
+            return false;
+
+        mSet = newSet.forget();
+    }
+    return true;
+}
+
+XPCWrappedNativeTearOff*
+XPCWrappedNative::FindTearOff(XPCNativeInterface* aInterface,
+                              bool needJSObject /* = false */,
+                              nsresult* pError /* = nullptr */)
+{
+    AutoJSContext cx;
+    nsresult rv = NS_OK;
+    XPCWrappedNativeTearOff* to;
+    XPCWrappedNativeTearOff* firstAvailable = nullptr;
+
+    XPCWrappedNativeTearOff* lastTearOff;
+    for (lastTearOff = to = &mFirstTearOff;
+         to;
+         lastTearOff = to, to = to->GetNextTearOff()) {
+        if (to->GetInterface() == aInterface) {
+            if (needJSObject && !to->GetJSObjectPreserveColor()) {
+                AutoMarkingWrappedNativeTearOffPtr tearoff(cx, to);
+                bool ok = InitTearOffJSObject(to);
+                // During shutdown, we don't sweep tearoffs.  So make sure
+                // to unmark manually in case the auto-marker marked us.
+                // We shouldn't ever be getting here _during_ our
+                // Mark/Sweep cycle, so this should be safe.
+                to->Unmark();
+                if (!ok) {
+                    to = nullptr;
+                    rv = NS_ERROR_OUT_OF_MEMORY;
+                }
+            }
+            if (pError)
+                *pError = rv;
+            return to;
+        }
+        if (!firstAvailable && to->IsAvailable())
+            firstAvailable = to;
+    }
+
+    to = firstAvailable;
+
+    if (!to) {
+        to = lastTearOff->AddTearOff();
+    }
+
+    {
+        // Scope keeps |tearoff| from leaking across the rest of the function.
+        AutoMarkingWrappedNativeTearOffPtr tearoff(cx, to);
+        rv = InitTearOff(to, aInterface, needJSObject);
+        // During shutdown, we don't sweep tearoffs.  So make sure to unmark
+        // manually in case the auto-marker marked us.  We shouldn't ever be
+        // getting here _during_ our Mark/Sweep cycle, so this should be safe.
+        to->Unmark();
+        if (NS_FAILED(rv))
+            to = nullptr;
+    }
+
+    if (pError)
+        *pError = rv;
+    return to;
+}
+
+XPCWrappedNativeTearOff*
+XPCWrappedNative::FindTearOff(const nsIID& iid) {
+    RefPtr<XPCNativeInterface> iface = XPCNativeInterface::GetNewOrUsed(&iid);
+    return iface ? FindTearOff(iface) : nullptr;
+}
+
+nsresult
+XPCWrappedNative::InitTearOff(XPCWrappedNativeTearOff* aTearOff,
+                              XPCNativeInterface* aInterface,
+                              bool needJSObject)
+{
+    AutoJSContext cx;
+
+    // Determine if the object really does this interface...
+
+    const nsIID* iid = aInterface->GetIID();
+    nsISupports* identity = GetIdentityObject();
+
+    // This is an nsRefPtr instead of an nsCOMPtr because it may not be the
+    // canonical nsISupports for this object.
+    RefPtr<nsISupports> qiResult;
+
+    // If the scriptable helper forbids us from reflecting additional
+    // interfaces, then don't even try the QI, just fail.
+    if (mScriptableInfo &&
+        mScriptableInfo->GetFlags().ClassInfoInterfacesOnly() &&
+        !mSet->HasInterface(aInterface) &&
+        !mSet->HasInterfaceWithAncestor(aInterface)) {
+        return NS_ERROR_NO_INTERFACE;
+    }
+
+    // We are about to call out to other code.
+    // So protect our intended tearoff.
+
+    aTearOff->SetReserved();
+
+    if (NS_FAILED(identity->QueryInterface(*iid, getter_AddRefs(qiResult))) || !qiResult) {
+        aTearOff->SetInterface(nullptr);
+        return NS_ERROR_NO_INTERFACE;
+    }
+
+    // Guard against trying to build a tearoff for a shared nsIClassInfo.
+    if (iid->Equals(NS_GET_IID(nsIClassInfo))) {
+        nsCOMPtr<nsISupports> alternate_identity(do_QueryInterface(qiResult));
+        if (alternate_identity.get() != identity) {
+            aTearOff->SetInterface(nullptr);
+            return NS_ERROR_NO_INTERFACE;
+        }
+    }
+
+    // Guard against trying to build a tearoff for an interface that is
+    // aggregated and is implemented as a nsIXPConnectWrappedJS using this
+    // self-same JSObject. The XBL system does this. If we mutate the set
+    // of this wrapper then we will shadow the method that XBL has added to
+    // the JSObject that it has inserted in the JS proto chain between our
+    // JSObject and our XPCWrappedNativeProto's JSObject. If we let this
+    // set mutation happen then the interface's methods will be added to
+    // our JSObject, but calls on those methods will get routed up to
+    // native code and into the wrappedJS - which will do a method lookup
+    // on *our* JSObject and find the same method and make another call
+    // into an infinite loop.
+    // see: http://bugzilla.mozilla.org/show_bug.cgi?id=96725
+
+    // The code in this block also does a check for the double wrapped
+    // nsIPropertyBag case.
+
+    nsCOMPtr<nsIXPConnectWrappedJS> wrappedJS(do_QueryInterface(qiResult));
+    if (wrappedJS) {
+        RootedObject jso(cx, wrappedJS->GetJSObject());
+        if (jso == mFlatJSObject) {
+            // The implementing JSObject is the same as ours! Just say OK
+            // without actually extending the set.
+            //
+            // XXX It is a little cheesy to have FindTearOff return an
+            // 'empty' tearoff. But this is the centralized place to do the
+            // QI activities on the underlying object. *And* most caller to
+            // FindTearOff only look for a non-null result and ignore the
+            // actual tearoff returned. The only callers that do use the
+            // returned tearoff make sure to check for either a non-null
+            // JSObject or a matching Interface before proceeding.
+            // I think we can get away with this bit of ugliness.
+
+            aTearOff->SetInterface(nullptr);
+            return NS_OK;
+        }
+
+        // Decide whether or not to expose nsIPropertyBag to calling
+        // JS code in the double wrapped case.
+        //
+        // Our rule here is that when JSObjects are double wrapped and
+        // exposed to other JSObjects then the nsIPropertyBag interface
+        // is only exposed on an 'opt-in' basis; i.e. if the underlying
+        // JSObject wants other JSObjects to be able to see this interface
+        // then it must implement QueryInterface and not throw an exception
+        // when asked for nsIPropertyBag. It need not actually *implement*
+        // nsIPropertyBag - xpconnect will do that work.
+
+        if (iid->Equals(NS_GET_IID(nsIPropertyBag)) && jso) {
+            RefPtr<nsXPCWrappedJSClass> clasp = nsXPCWrappedJSClass::GetNewOrUsed(cx, *iid);
+            if (clasp) {
+                RootedObject answer(cx, clasp->CallQueryInterfaceOnJSObject(cx, jso, *iid));
+
+                if (!answer) {
+                    aTearOff->SetInterface(nullptr);
+                    return NS_ERROR_NO_INTERFACE;
+                }
+            }
+        }
+    }
+
+    if (NS_FAILED(nsXPConnect::SecurityManager()->CanCreateWrapper(cx, *iid, identity,
+                                                                   GetClassInfo()))) {
+        // the security manager vetoed. It should have set an exception.
+        aTearOff->SetInterface(nullptr);
+        return NS_ERROR_XPC_SECURITY_MANAGER_VETO;
+    }
+
+    // If this is not already in our set we need to extend our set.
+    // Note: we do not cache the result of the previous call to HasInterface()
+    // because we unlocked and called out in the interim and the result of the
+    // previous call might not be correct anymore.
+
+    if (!mSet->HasInterface(aInterface) && !ExtendSet(aInterface)) {
+        aTearOff->SetInterface(nullptr);
+        return NS_ERROR_NO_INTERFACE;
+    }
+
+    aTearOff->SetInterface(aInterface);
+    aTearOff->SetNative(qiResult);
+    if (needJSObject && !InitTearOffJSObject(aTearOff))
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    return NS_OK;
+}
+
+bool
+XPCWrappedNative::InitTearOffJSObject(XPCWrappedNativeTearOff* to)
+{
+    AutoJSContext cx;
+
+    JSObject* obj = JS_NewObject(cx, Jsvalify(&XPC_WN_Tearoff_JSClass));
+    if (!obj)
+        return false;
+
+    JS_SetPrivate(obj, to);
+    to->SetJSObject(obj);
+
+    js::SetReservedSlot(obj, XPC_WN_TEAROFF_FLAT_OBJECT_SLOT,
+                        JS::ObjectValue(*mFlatJSObject));
+    return true;
+}
+
+/***************************************************************************/
+
+static bool Throw(nsresult errNum, XPCCallContext& ccx)
+{
+    XPCThrower::Throw(errNum, ccx);
+    return false;
+}
+
+/***************************************************************************/
+
+class MOZ_STACK_CLASS CallMethodHelper
+{
+    XPCCallContext& mCallContext;
+    nsresult mInvokeResult;
+    nsIInterfaceInfo* const mIFaceInfo;
+    const nsXPTMethodInfo* mMethodInfo;
+    nsISupports* const mCallee;
+    const uint16_t mVTableIndex;
+    HandleId mIdxValueId;
+
+    AutoTArray<nsXPTCVariant, 8> mDispatchParams;
+    uint8_t mJSContextIndex; // TODO make const
+    uint8_t mOptArgcIndex; // TODO make const
+
+    Value* const mArgv;
+    const uint32_t mArgc;
+
+    MOZ_ALWAYS_INLINE bool
+    GetArraySizeFromParam(uint8_t paramIndex, HandleValue maybeArray, uint32_t* result);
+
+    MOZ_ALWAYS_INLINE bool
+    GetInterfaceTypeFromParam(uint8_t paramIndex,
+                              const nsXPTType& datum_type,
+                              nsID* result) const;
+
+    MOZ_ALWAYS_INLINE bool
+    GetOutParamSource(uint8_t paramIndex, MutableHandleValue srcp) const;
+
+    MOZ_ALWAYS_INLINE bool
+    GatherAndConvertResults();
+
+    MOZ_ALWAYS_INLINE bool
+    QueryInterfaceFastPath();
+
+    nsXPTCVariant*
+    GetDispatchParam(uint8_t paramIndex)
+    {
+        if (paramIndex >= mJSContextIndex)
+            paramIndex += 1;
+        if (paramIndex >= mOptArgcIndex)
+            paramIndex += 1;
+        return &mDispatchParams[paramIndex];
+    }
+    const nsXPTCVariant*
+    GetDispatchParam(uint8_t paramIndex) const
+    {
+        return const_cast<CallMethodHelper*>(this)->GetDispatchParam(paramIndex);
+    }
+
+    MOZ_ALWAYS_INLINE bool InitializeDispatchParams();
+
+    MOZ_ALWAYS_INLINE bool ConvertIndependentParams(bool* foundDependentParam);
+    MOZ_ALWAYS_INLINE bool ConvertIndependentParam(uint8_t i);
+    MOZ_ALWAYS_INLINE bool ConvertDependentParams();
+    MOZ_ALWAYS_INLINE bool ConvertDependentParam(uint8_t i);
+
+    MOZ_ALWAYS_INLINE void CleanupParam(nsXPTCMiniVariant& param, nsXPTType& type);
+
+    MOZ_ALWAYS_INLINE bool AllocateStringClass(nsXPTCVariant* dp,
+                                               const nsXPTParamInfo& paramInfo);
+
+    MOZ_ALWAYS_INLINE nsresult Invoke();
+
+public:
+
+    explicit CallMethodHelper(XPCCallContext& ccx)
+        : mCallContext(ccx)
+        , mInvokeResult(NS_ERROR_UNEXPECTED)
+        , mIFaceInfo(ccx.GetInterface()->GetInterfaceInfo())
+        , mMethodInfo(nullptr)
+        , mCallee(ccx.GetTearOff()->GetNative())
+        , mVTableIndex(ccx.GetMethodIndex())
+        , mIdxValueId(ccx.GetContext()->GetStringID(XPCJSContext::IDX_VALUE))
+        , mJSContextIndex(UINT8_MAX)
+        , mOptArgcIndex(UINT8_MAX)
+        , mArgv(ccx.GetArgv())
+        , mArgc(ccx.GetArgc())
+
+    {
+        // Success checked later.
+        mIFaceInfo->GetMethodInfo(mVTableIndex, &mMethodInfo);
+    }
+
+    ~CallMethodHelper();
+
+    MOZ_ALWAYS_INLINE bool Call();
+
+};
+
+// static
+bool
+XPCWrappedNative::CallMethod(XPCCallContext& ccx,
+                             CallMode mode /*= CALL_METHOD */)
+{
+    nsresult rv = ccx.CanCallNow();
+    if (NS_FAILED(rv)) {
+        return Throw(rv, ccx);
+    }
+
+    return CallMethodHelper(ccx).Call();
+}
+
+bool
+CallMethodHelper::Call()
+{
+    mCallContext.SetRetVal(JS::UndefinedValue());
+
+    XPCJSContext::Get()->SetPendingException(nullptr);
+
+    if (mVTableIndex == 0) {
+        return QueryInterfaceFastPath();
+    }
+
+    if (!mMethodInfo) {
+        Throw(NS_ERROR_XPC_CANT_GET_METHOD_INFO, mCallContext);
+        return false;
+    }
+
+    if (!InitializeDispatchParams())
+        return false;
+
+    // Iterate through the params doing conversions of independent params only.
+    // When we later convert the dependent params (if any) we will know that
+    // the params upon which they depend will have already been converted -
+    // regardless of ordering.
+    bool foundDependentParam = false;
+    if (!ConvertIndependentParams(&foundDependentParam))
+        return false;
+
+    if (foundDependentParam && !ConvertDependentParams())
+        return false;
+
+    mInvokeResult = Invoke();
+
+    if (JS_IsExceptionPending(mCallContext)) {
+        return false;
+    }
+
+    if (NS_FAILED(mInvokeResult)) {
+        ThrowBadResult(mInvokeResult, mCallContext);
+        return false;
+    }
+
+    return GatherAndConvertResults();
+}
+
+CallMethodHelper::~CallMethodHelper()
+{
+    uint8_t paramCount = mMethodInfo->GetParamCount();
+    if (mDispatchParams.Length()) {
+        for (uint8_t i = 0; i < paramCount; i++) {
+            nsXPTCVariant* dp = GetDispatchParam(i);
+            const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(i);
+
+            if (paramInfo.GetType().IsArray()) {
+                void* p = dp->val.p;
+                if (!p)
+                    continue;
+
+                // Clean up the array contents if necessary.
+                if (dp->DoesValNeedCleanup()) {
+                    // We need some basic information to properly destroy the array.
+                    uint32_t array_count = 0;
+                    nsXPTType datum_type;
+                    if (!GetArraySizeFromParam(i, UndefinedHandleValue, &array_count) ||
+                        !NS_SUCCEEDED(mIFaceInfo->GetTypeForParam(mVTableIndex,
+                                                                  &paramInfo,
+                                                                  1, &datum_type))) {
+                        // XXXbholley - I'm not convinced that the above calls will
+                        // ever fail.
+                        NS_ERROR("failed to get array information, we'll leak here");
+                        continue;
+                    }
+
+                    // Loop over the array contents. For each one, we create a
+                    // dummy 'val' and pass it to the cleanup helper.
+                    for (uint32_t k = 0; k < array_count; k++) {
+                        nsXPTCMiniVariant v;
+                        v.val.p = static_cast<void**>(p)[k];
+                        CleanupParam(v, datum_type);
+                    }
+                }
+
+                // always free the array itself
+                free(p);
+            } else {
+                // Clean up single parameters (if requested).
+                if (dp->DoesValNeedCleanup())
+                    CleanupParam(*dp, dp->type);
+            }
+        }
+    }
+}
+
+bool
+CallMethodHelper::GetArraySizeFromParam(uint8_t paramIndex,
+                                        HandleValue maybeArray,
+                                        uint32_t* result)
+{
+    nsresult rv;
+    const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(paramIndex);
+
+    // TODO fixup the various exceptions that are thrown
+
+    rv = mIFaceInfo->GetSizeIsArgNumberForParam(mVTableIndex, &paramInfo, 0, &paramIndex);
+    if (NS_FAILED(rv))
+        return Throw(NS_ERROR_XPC_CANT_GET_ARRAY_INFO, mCallContext);
+
+    // If the array length wasn't passed, it might have been listed as optional.
+    // When converting arguments from JS to C++, we pass the array as |maybeArray|,
+    // and give ourselves the chance to infer the length. Once we have it, we stick
+    // it in the right slot so that we can find it again when cleaning up the params.
+    // from the array.
+    if (paramIndex >= mArgc && maybeArray.isObject()) {
+        MOZ_ASSERT(mMethodInfo->GetParam(paramIndex).IsOptional());
+        RootedObject arrayOrNull(mCallContext, maybeArray.isObject() ? &maybeArray.toObject()
+                                                                     : nullptr);
+
+        bool isArray;
+        if (!JS_IsArrayObject(mCallContext, maybeArray, &isArray) ||
+            !isArray ||
+            !JS_GetArrayLength(mCallContext, arrayOrNull, &GetDispatchParam(paramIndex)->val.u32))
+        {
+            return Throw(NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY, mCallContext);
+        }
+    }
+
+    *result = GetDispatchParam(paramIndex)->val.u32;
+
+    return true;
+}
+
+bool
+CallMethodHelper::GetInterfaceTypeFromParam(uint8_t paramIndex,
+                                            const nsXPTType& datum_type,
+                                            nsID* result) const
+{
+    nsresult rv;
+    const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(paramIndex);
+    uint8_t tag = datum_type.TagPart();
+
+    // TODO fixup the various exceptions that are thrown
+
+    if (tag == nsXPTType::T_INTERFACE) {
+        rv = mIFaceInfo->GetIIDForParamNoAlloc(mVTableIndex, &paramInfo, result);
+        if (NS_FAILED(rv))
+            return ThrowBadParam(NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO,
+                                 paramIndex, mCallContext);
+    } else if (tag == nsXPTType::T_INTERFACE_IS) {
+        rv = mIFaceInfo->GetInterfaceIsArgNumberForParam(mVTableIndex, &paramInfo,
+                                                         &paramIndex);
+        if (NS_FAILED(rv))
+            return Throw(NS_ERROR_XPC_CANT_GET_ARRAY_INFO, mCallContext);
+
+        nsID* p = (nsID*) GetDispatchParam(paramIndex)->val.p;
+        if (!p)
+            return ThrowBadParam(NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO,
+                                 paramIndex, mCallContext);
+        *result = *p;
+    }
+    return true;
+}
+
+bool
+CallMethodHelper::GetOutParamSource(uint8_t paramIndex, MutableHandleValue srcp) const
+{
+    const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(paramIndex);
+
+    MOZ_ASSERT(!paramInfo.IsDipper(), "Dipper params are handled separately");
+    if (paramInfo.IsOut() && !paramInfo.IsRetval()) {
+        MOZ_ASSERT(paramIndex < mArgc || paramInfo.IsOptional(),
+                   "Expected either enough arguments or an optional argument");
+        Value arg = paramIndex < mArgc ? mArgv[paramIndex] : JS::NullValue();
+        if (paramIndex < mArgc) {
+            RootedObject obj(mCallContext);
+            if (!arg.isPrimitive())
+                obj = &arg.toObject();
+            if (!obj || !JS_GetPropertyById(mCallContext, obj, mIdxValueId, srcp)) {
+                // Explicitly passed in unusable value for out param.  Note
+                // that if i >= mArgc we already know that |arg| is JS::NullValue(),
+                // and that's ok.
+                ThrowBadParam(NS_ERROR_XPC_NEED_OUT_OBJECT, paramIndex,
+                              mCallContext);
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+bool
+CallMethodHelper::GatherAndConvertResults()
+{
+    // now we iterate through the native params to gather and convert results
+    uint8_t paramCount = mMethodInfo->GetParamCount();
+    for (uint8_t i = 0; i < paramCount; i++) {
+        const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(i);
+        if (!paramInfo.IsOut() && !paramInfo.IsDipper())
+            continue;
+
+        const nsXPTType& type = paramInfo.GetType();
+        nsXPTCVariant* dp = GetDispatchParam(i);
+        RootedValue v(mCallContext, NullValue());
+        uint32_t array_count = 0;
+        nsXPTType datum_type;
+        bool isArray = type.IsArray();
+        bool isSizedString = isArray ?
+                false :
+                type.TagPart() == nsXPTType::T_PSTRING_SIZE_IS ||
+                type.TagPart() == nsXPTType::T_PWSTRING_SIZE_IS;
+
+        if (isArray) {
+            if (NS_FAILED(mIFaceInfo->GetTypeForParam(mVTableIndex, &paramInfo, 1,
+                                                      &datum_type))) {
+                Throw(NS_ERROR_XPC_CANT_GET_ARRAY_INFO, mCallContext);
+                return false;
+            }
+        } else
+            datum_type = type;
+
+        if (isArray || isSizedString) {
+            if (!GetArraySizeFromParam(i, UndefinedHandleValue, &array_count))
+                return false;
+        }
+
+        nsID param_iid;
+        if (datum_type.IsInterfacePointer() &&
+            !GetInterfaceTypeFromParam(i, datum_type, &param_iid))
+            return false;
+
+        nsresult err;
+        if (isArray) {
+            if (!XPCConvert::NativeArray2JS(&v, (const void**)&dp->val,
+                                            datum_type, &param_iid,
+                                            array_count, &err)) {
+                // XXX need exception scheme for arrays to indicate bad element
+                ThrowBadParam(err, i, mCallContext);
+                return false;
+            }
+        } else if (isSizedString) {
+            if (!XPCConvert::NativeStringWithSize2JS(&v,
+                                                     (const void*)&dp->val,
+                                                     datum_type,
+                                                     array_count, &err)) {
+                ThrowBadParam(err, i, mCallContext);
+                return false;
+            }
+        } else {
+            if (!XPCConvert::NativeData2JS(&v, &dp->val, datum_type,
+                                           &param_iid, &err)) {
+                ThrowBadParam(err, i, mCallContext);
+                return false;
+            }
+        }
+
+        if (paramInfo.IsRetval()) {
+            mCallContext.SetRetVal(v);
+        } else if (i < mArgc) {
+            // we actually assured this before doing the invoke
+            MOZ_ASSERT(mArgv[i].isObject(), "out var is not object");
+            RootedObject obj(mCallContext, &mArgv[i].toObject());
+            if (!JS_SetPropertyById(mCallContext, obj, mIdxValueId, v)) {
+                ThrowBadParam(NS_ERROR_XPC_CANT_SET_OUT_VAL, i, mCallContext);
+                return false;
+            }
+        } else {
+            MOZ_ASSERT(paramInfo.IsOptional(),
+                       "Expected either enough arguments or an optional argument");
+        }
+    }
+
+    return true;
+}
+
+bool
+CallMethodHelper::QueryInterfaceFastPath()
+{
+    MOZ_ASSERT(mVTableIndex == 0,
+               "Using the QI fast-path for a method other than QueryInterface");
+
+    if (mArgc < 1) {
+        Throw(NS_ERROR_XPC_NOT_ENOUGH_ARGS, mCallContext);
+        return false;
+    }
+
+    if (!mArgv[0].isObject()) {
+        ThrowBadParam(NS_ERROR_XPC_BAD_CONVERT_JS, 0, mCallContext);
+        return false;
+    }
+
+    const nsID* iid = xpc_JSObjectToID(mCallContext, &mArgv[0].toObject());
+    if (!iid) {
+        ThrowBadParam(NS_ERROR_XPC_BAD_CONVERT_JS, 0, mCallContext);
+        return false;
+    }
+
+    nsISupports* qiresult = nullptr;
+    mInvokeResult = mCallee->QueryInterface(*iid, (void**) &qiresult);
+
+    if (NS_FAILED(mInvokeResult)) {
+        ThrowBadResult(mInvokeResult, mCallContext);
+        return false;
+    }
+
+    RootedValue v(mCallContext, NullValue());
+    nsresult err;
+    bool success =
+        XPCConvert::NativeData2JS(&v, &qiresult,
+                                  nsXPTType::T_INTERFACE_IS,
+                                  iid, &err);
+    NS_IF_RELEASE(qiresult);
+
+    if (!success) {
+        ThrowBadParam(err, 0, mCallContext);
+        return false;
+    }
+
+    mCallContext.SetRetVal(v);
+    return true;
+}
+
+bool
+CallMethodHelper::InitializeDispatchParams()
+{
+    const uint8_t wantsOptArgc = mMethodInfo->WantsOptArgc() ? 1 : 0;
+    const uint8_t wantsJSContext = mMethodInfo->WantsContext() ? 1 : 0;
+    const uint8_t paramCount = mMethodInfo->GetParamCount();
+    uint8_t requiredArgs = paramCount;
+    uint8_t hasRetval = 0;
+
+    // XXX ASSUMES that retval is last arg. The xpidl compiler ensures this.
+    if (paramCount && mMethodInfo->GetParam(paramCount-1).IsRetval()) {
+        hasRetval = 1;
+        requiredArgs--;
+    }
+
+    if (mArgc < requiredArgs || wantsOptArgc) {
+        if (wantsOptArgc)
+            mOptArgcIndex = requiredArgs;
+
+        // skip over any optional arguments
+        while (requiredArgs && mMethodInfo->GetParam(requiredArgs-1).IsOptional())
+            requiredArgs--;
+
+        if (mArgc < requiredArgs) {
+            Throw(NS_ERROR_XPC_NOT_ENOUGH_ARGS, mCallContext);
+            return false;
+        }
+    }
+
+    if (wantsJSContext) {
+        if (wantsOptArgc)
+            // Need to bump mOptArgcIndex up one here.
+            mJSContextIndex = mOptArgcIndex++;
+        else if (mMethodInfo->IsSetter() || mMethodInfo->IsGetter())
+            // For attributes, we always put the JSContext* first.
+            mJSContextIndex = 0;
+        else
+            mJSContextIndex = paramCount - hasRetval;
+    }
+
+    // iterate through the params to clear flags (for safe cleanup later)
+    for (uint8_t i = 0; i < paramCount + wantsJSContext + wantsOptArgc; i++) {
+        nsXPTCVariant* dp = mDispatchParams.AppendElement();
+        dp->ClearFlags();
+        dp->val.p = nullptr;
+    }
+
+    // Fill in the JSContext argument
+    if (wantsJSContext) {
+        nsXPTCVariant* dp = &mDispatchParams[mJSContextIndex];
+        dp->type = nsXPTType::T_VOID;
+        dp->val.p = mCallContext;
+    }
+
+    // Fill in the optional_argc argument
+    if (wantsOptArgc) {
+        nsXPTCVariant* dp = &mDispatchParams[mOptArgcIndex];
+        dp->type = nsXPTType::T_U8;
+        dp->val.u8 = std::min<uint32_t>(mArgc, paramCount) - requiredArgs;
+    }
+
+    return true;
+}
+
+bool
+CallMethodHelper::ConvertIndependentParams(bool* foundDependentParam)
+{
+    const uint8_t paramCount = mMethodInfo->GetParamCount();
+    for (uint8_t i = 0; i < paramCount; i++) {
+        const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(i);
+
+        if (paramInfo.GetType().IsDependent())
+            *foundDependentParam = true;
+        else if (!ConvertIndependentParam(i))
+            return false;
+
+    }
+
+    return true;
+}
+
+bool
+CallMethodHelper::ConvertIndependentParam(uint8_t i)
+{
+    const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(i);
+    const nsXPTType& type = paramInfo.GetType();
+    uint8_t type_tag = type.TagPart();
+    nsXPTCVariant* dp = GetDispatchParam(i);
+    dp->type = type;
+    MOZ_ASSERT(!paramInfo.IsShared(), "[shared] implies [noscript]!");
+
+    // String classes are always "in" - those that are marked "out" are converted
+    // by the XPIDL compiler to "in+dipper". See the note above IsDipper() in
+    // xptinfo.h.
+    //
+    // Also note that the fact that we bail out early for dipper parameters means
+    // that "inout" dipper parameters don't work - see bug 687612.
+    if (paramInfo.IsStringClass()) {
+        if (!AllocateStringClass(dp, paramInfo))
+            return false;
+        if (paramInfo.IsDipper()) {
+            // We've allocated our string class explicitly, so we don't need
+            // to do any conversions on the incoming argument. However, we still
+            // need to verify that it's an object, so that we don't get surprised
+            // later on when trying to assign the result to .value.
+            if (i < mArgc && !mArgv[i].isObject()) {
+                ThrowBadParam(NS_ERROR_XPC_NEED_OUT_OBJECT, i, mCallContext);
+                return false;
+            }
+            return true;
+        }
+    }
+
+    // Specify the correct storage/calling semantics.
+    if (paramInfo.IsIndirect())
+        dp->SetIndirect();
+
+    // The JSVal proper is always stored within the 'val' union and passed
+    // indirectly, regardless of in/out-ness.
+    if (type_tag == nsXPTType::T_JSVAL) {
+        // Root the value.
+        dp->val.j.setUndefined();
+        if (!js::AddRawValueRoot(mCallContext, &dp->val.j, "XPCWrappedNative::CallMethod param"))
+            return false;
+    }
+
+    // Flag cleanup for anything that isn't self-contained.
+    if (!type.IsArithmetic())
+        dp->SetValNeedsCleanup();
+
+    // Even if there's nothing to convert, we still need to examine the
+    // JSObject container for out-params. If it's null or otherwise invalid,
+    // we want to know before the call, rather than after.
+    //
+    // This is a no-op for 'in' params.
+    RootedValue src(mCallContext);
+    if (!GetOutParamSource(i, &src))
+        return false;
+
+    // All that's left to do is value conversion. Bail early if we don't need
+    // to do that.
+    if (!paramInfo.IsIn())
+        return true;
+
+    // We're definitely some variety of 'in' now, so there's something to
+    // convert. The source value for conversion depends on whether we're
+    // dealing with an 'in' or an 'inout' parameter. 'inout' was handled above,
+    // so all that's left is 'in'.
+    if (!paramInfo.IsOut()) {
+        // Handle the 'in' case.
+        MOZ_ASSERT(i < mArgc || paramInfo.IsOptional(),
+                   "Expected either enough arguments or an optional argument");
+        if (i < mArgc)
+            src = mArgv[i];
+        else if (type_tag == nsXPTType::T_JSVAL)
+            src.setUndefined();
+        else
+            src.setNull();
+    }
+
+    nsID param_iid;
+    if (type_tag == nsXPTType::T_INTERFACE &&
+        NS_FAILED(mIFaceInfo->GetIIDForParamNoAlloc(mVTableIndex, &paramInfo,
+                                                    &param_iid))) {
+        ThrowBadParam(NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO, i, mCallContext);
+        return false;
+    }
+
+    // Don't allow CPOWs to be passed to native code (in case they try to cast
+    // to a concrete type).
+    if (src.isObject() &&
+        jsipc::IsWrappedCPOW(&src.toObject()) &&
+        type_tag == nsXPTType::T_INTERFACE &&
+        !param_iid.Equals(NS_GET_IID(nsISupports)))
+    {
+        // Allow passing CPOWs to XPCWrappedJS.
+        nsCOMPtr<nsIXPConnectWrappedJS> wrappedJS(do_QueryInterface(mCallee));
+        if (!wrappedJS) {
+            ThrowBadParam(NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE, i, mCallContext);
+            return false;
+        }
+    }
+
+    nsresult err;
+    if (!XPCConvert::JSData2Native(&dp->val, src, type, &param_iid, &err)) {
+        ThrowBadParam(err, i, mCallContext);
+        return false;
+    }
+
+    return true;
+}
+
+bool
+CallMethodHelper::ConvertDependentParams()
+{
+    const uint8_t paramCount = mMethodInfo->GetParamCount();
+    for (uint8_t i = 0; i < paramCount; i++) {
+        const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(i);
+
+        if (!paramInfo.GetType().IsDependent())
+            continue;
+        if (!ConvertDependentParam(i))
+            return false;
+    }
+
+    return true;
+}
+
+bool
+CallMethodHelper::ConvertDependentParam(uint8_t i)
+{
+    const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(i);
+    const nsXPTType& type = paramInfo.GetType();
+    nsXPTType datum_type;
+    uint32_t array_count = 0;
+    bool isArray = type.IsArray();
+
+    bool isSizedString = isArray ?
+        false :
+        type.TagPart() == nsXPTType::T_PSTRING_SIZE_IS ||
+        type.TagPart() == nsXPTType::T_PWSTRING_SIZE_IS;
+
+    nsXPTCVariant* dp = GetDispatchParam(i);
+    dp->type = type;
+
+    if (isArray) {
+        if (NS_FAILED(mIFaceInfo->GetTypeForParam(mVTableIndex, &paramInfo, 1,
+                                                  &datum_type))) {
+            Throw(NS_ERROR_XPC_CANT_GET_ARRAY_INFO, mCallContext);
+            return false;
+        }
+        MOZ_ASSERT(datum_type.TagPart() != nsXPTType::T_JSVAL,
+                   "Arrays of JSVals not currently supported - see bug 693337.");
+    } else {
+        datum_type = type;
+    }
+
+    // Specify the correct storage/calling semantics.
+    if (paramInfo.IsIndirect())
+        dp->SetIndirect();
+
+    // We have 3 possible type of dependent parameters: Arrays, Sized Strings,
+    // and iid_is Interface pointers. The latter two always need cleanup, and
+    // arrays need cleanup for all non-arithmetic types. Since the latter two
+    // cases also happen to be non-arithmetic, we can just inspect datum_type
+    // here.
+    if (!datum_type.IsArithmetic())
+        dp->SetValNeedsCleanup();
+
+    // Even if there's nothing to convert, we still need to examine the
+    // JSObject container for out-params. If it's null or otherwise invalid,
+    // we want to know before the call, rather than after.
+    //
+    // This is a no-op for 'in' params.
+    RootedValue src(mCallContext);
+    if (!GetOutParamSource(i, &src))
+        return false;
+
+    // All that's left to do is value conversion. Bail early if we don't need
+    // to do that.
+    if (!paramInfo.IsIn())
+        return true;
+
+    // We're definitely some variety of 'in' now, so there's something to
+    // convert. The source value for conversion depends on whether we're
+    // dealing with an 'in' or an 'inout' parameter. 'inout' was handled above,
+    // so all that's left is 'in'.
+    if (!paramInfo.IsOut()) {
+        // Handle the 'in' case.
+        MOZ_ASSERT(i < mArgc || paramInfo.IsOptional(),
+                     "Expected either enough arguments or an optional argument");
+        src = i < mArgc ? mArgv[i] : JS::NullValue();
+    }
+
+    nsID param_iid;
+    if (datum_type.IsInterfacePointer() &&
+        !GetInterfaceTypeFromParam(i, datum_type, &param_iid))
+        return false;
+
+    nsresult err;
+
+    if (isArray || isSizedString) {
+        if (!GetArraySizeFromParam(i, src, &array_count))
+            return false;
+
+        if (isArray) {
+            if (array_count &&
+                !XPCConvert::JSArray2Native((void**)&dp->val, src,
+                                            array_count, datum_type, &param_iid,
+                                            &err)) {
+                // XXX need exception scheme for arrays to indicate bad element
+                ThrowBadParam(err, i, mCallContext);
+                return false;
+            }
+        } else // if (isSizedString)
+        {
+            if (!XPCConvert::JSStringWithSize2Native((void*)&dp->val,
+                                                     src, array_count,
+                                                     datum_type, &err)) {
+                ThrowBadParam(err, i, mCallContext);
+                return false;
+            }
+        }
+    } else {
+        if (!XPCConvert::JSData2Native(&dp->val, src, type,
+                                       &param_iid, &err)) {
+            ThrowBadParam(err, i, mCallContext);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// Performs all necessary teardown on a parameter after method invocation.
+//
+// This method should only be called if the value in question was flagged
+// for cleanup (ie, if dp->DoesValNeedCleanup()).
+void
+CallMethodHelper::CleanupParam(nsXPTCMiniVariant& param, nsXPTType& type)
+{
+    // We handle array elements, but not the arrays themselves.
+    MOZ_ASSERT(type.TagPart() != nsXPTType::T_ARRAY, "Can't handle arrays.");
+
+    // Pointers may sometimes be null even if cleanup was requested. Combine
+    // the null checking for all the different types into one check here.
+    if (type.TagPart() != nsXPTType::T_JSVAL && param.val.p == nullptr)
+        return;
+
+    switch (type.TagPart()) {
+        case nsXPTType::T_JSVAL:
+            js::RemoveRawValueRoot(mCallContext, (Value*)&param.val);
+            break;
+        case nsXPTType::T_INTERFACE:
+        case nsXPTType::T_INTERFACE_IS:
+            ((nsISupports*)param.val.p)->Release();
+            break;
+        case nsXPTType::T_ASTRING:
+        case nsXPTType::T_DOMSTRING:
+            nsXPConnect::GetContextInstance()->mScratchStrings.Destroy((nsString*)param.val.p);
+            break;
+        case nsXPTType::T_UTF8STRING:
+        case nsXPTType::T_CSTRING:
+            nsXPConnect::GetContextInstance()->mScratchCStrings.Destroy((nsCString*)param.val.p);
+            break;
+        default:
+            MOZ_ASSERT(!type.IsArithmetic(), "Cleanup requested on unexpected type.");
+            free(param.val.p);
+            break;
+    }
+}
+
+bool
+CallMethodHelper::AllocateStringClass(nsXPTCVariant* dp,
+                                      const nsXPTParamInfo& paramInfo)
+{
+    // Get something we can make comparisons with.
+    uint8_t type_tag = paramInfo.GetType().TagPart();
+
+    // There should be 4 cases, all strings. Verify that here.
+    MOZ_ASSERT(type_tag == nsXPTType::T_ASTRING ||
+               type_tag == nsXPTType::T_DOMSTRING ||
+               type_tag == nsXPTType::T_UTF8STRING ||
+               type_tag == nsXPTType::T_CSTRING,
+               "Unexpected string class type!");
+
+    // ASTRING and DOMSTRING are very similar, and both use nsString.
+    // UTF8_STRING and CSTRING are also quite similar, and both use nsCString.
+    if (type_tag == nsXPTType::T_ASTRING || type_tag == nsXPTType::T_DOMSTRING)
+        dp->val.p = nsXPConnect::GetContextInstance()->mScratchStrings.Create();
+    else
+        dp->val.p = nsXPConnect::GetContextInstance()->mScratchCStrings.Create();
+
+    // Check for OOM, in either case.
+    if (!dp->val.p) {
+        JS_ReportOutOfMemory(mCallContext);
+        return false;
+    }
+
+    // We allocated, so we need to deallocate after the method call completes.
+    dp->SetValNeedsCleanup();
+
+    return true;
+}
+
+nsresult
+CallMethodHelper::Invoke()
+{
+    uint32_t argc = mDispatchParams.Length();
+    nsXPTCVariant* argv = mDispatchParams.Elements();
+
+    return NS_InvokeByIndex(mCallee, mVTableIndex, argc, argv);
+}
+
+/***************************************************************************/
+// interface methods
+
+JSObject*
+XPCWrappedNative::GetJSObject()
+{
+    return GetFlatJSObject();
+}
+
+NS_IMETHODIMP XPCWrappedNative::GetNative(nsISupports * *aNative)
+{
+    // No need to QI here, we already have the correct nsISupports
+    // vtable.
+    nsCOMPtr<nsISupports> rval = mIdentity;
+    rval.forget(aNative);
+    return NS_OK;
+}
+
+NS_IMETHODIMP XPCWrappedNative::GetJSObjectPrototype(JSObject * *aJSObjectPrototype)
+{
+    *aJSObjectPrototype = HasProto() ?
+                GetProto()->GetJSProtoObject() : GetFlatJSObject();
+    return NS_OK;
+}
+
+nsIPrincipal*
+XPCWrappedNative::GetObjectPrincipal() const
+{
+    nsIPrincipal* principal = GetScope()->GetPrincipal();
+#ifdef DEBUG
+    // Because of inner window reuse, we can have objects with one principal
+    // living in a scope with a different (but same-origin) principal. So
+    // just check same-origin here.
+    nsCOMPtr<nsIScriptObjectPrincipal> objPrin(do_QueryInterface(mIdentity));
+    if (objPrin) {
+        bool equal;
+        if (!principal)
+            equal = !objPrin->GetPrincipal();
+        else
+            principal->Equals(objPrin->GetPrincipal(), &equal);
+        MOZ_ASSERT(equal, "Principal mismatch.  Expect bad things to happen");
+    }
+#endif
+    return principal;
+}
+
+NS_IMETHODIMP XPCWrappedNative::FindInterfaceWithMember(HandleId name,
+                                                        nsIInterfaceInfo * *_retval)
+{
+    RefPtr<XPCNativeInterface> iface;
+    XPCNativeMember*  member;
+
+    if (GetSet()->FindMember(name, &member, &iface) && iface) {
+        nsCOMPtr<nsIInterfaceInfo> temp = iface->GetInterfaceInfo();
+        temp.forget(_retval);
+    } else
+        *_retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP XPCWrappedNative::FindInterfaceWithName(HandleId name,
+                                                      nsIInterfaceInfo * *_retval)
+{
+    XPCNativeInterface* iface = GetSet()->FindNamedInterface(name);
+    if (iface) {
+        nsCOMPtr<nsIInterfaceInfo> temp = iface->GetInterfaceInfo();
+        temp.forget(_retval);
+    } else
+        *_retval = nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP_(bool)
+XPCWrappedNative::HasNativeMember(HandleId name)
+{
+    XPCNativeMember* member = nullptr;
+    uint16_t ignored;
+    return GetSet()->FindMember(name, &member, &ignored) && !!member;
+}
+
+NS_IMETHODIMP XPCWrappedNative::DebugDump(int16_t depth)
+{
+#ifdef DEBUG
+    depth-- ;
+    XPC_LOG_ALWAYS(("XPCWrappedNative @ %x with mRefCnt = %d", this, mRefCnt.get()));
+    XPC_LOG_INDENT();
+
+        if (HasProto()) {
+            XPCWrappedNativeProto* proto = GetProto();
+            if (depth && proto)
+                proto->DebugDump(depth);
+            else
+                XPC_LOG_ALWAYS(("mMaybeProto @ %x", proto));
+        } else
+            XPC_LOG_ALWAYS(("Scope @ %x", GetScope()));
+
+        if (depth && mSet)
+            mSet->DebugDump(depth);
+        else
+            XPC_LOG_ALWAYS(("mSet @ %x", mSet.get()));
+
+        XPC_LOG_ALWAYS(("mFlatJSObject of %x", mFlatJSObject.unbarrieredGetPtr()));
+        XPC_LOG_ALWAYS(("mIdentity of %x", mIdentity.get()));
+        XPC_LOG_ALWAYS(("mScriptableInfo @ %x", mScriptableInfo));
+
+        if (depth && mScriptableInfo) {
+            XPC_LOG_INDENT();
+            XPC_LOG_ALWAYS(("mScriptable @ %x", mScriptableInfo->GetCallback()));
+            XPC_LOG_ALWAYS(("mFlags of %x", (uint32_t)mScriptableInfo->GetFlags()));
+            XPC_LOG_ALWAYS(("mJSClass @ %x", mScriptableInfo->GetJSClass()));
+            XPC_LOG_OUTDENT();
+        }
+    XPC_LOG_OUTDENT();
+#endif
+    return NS_OK;
+}
+
+/***************************************************************************/
+
+char*
+XPCWrappedNative::ToString(XPCWrappedNativeTearOff* to /* = nullptr */ ) const
+{
+#ifdef DEBUG
+#  define FMT_ADDR " @ 0x%p"
+#  define FMT_STR(str) str
+#  define PARAM_ADDR(w) , w
+#else
+#  define FMT_ADDR ""
+#  define FMT_STR(str)
+#  define PARAM_ADDR(w)
+#endif
+
+    char* sz = nullptr;
+    char* name = nullptr;
+
+    XPCNativeScriptableInfo* si = GetScriptableInfo();
+    if (si)
+        name = JS_smprintf("%s", si->GetJSClass()->name);
+    if (to) {
+        const char* fmt = name ? " (%s)" : "%s";
+        name = JS_sprintf_append(name, fmt,
+                                 to->GetInterface()->GetNameString());
+    } else if (!name) {
+        XPCNativeSet* set = GetSet();
+        XPCNativeInterface** array = set->GetInterfaceArray();
+        RefPtr<XPCNativeInterface> isupp = XPCNativeInterface::GetISupports();
+        uint16_t count = set->GetInterfaceCount();
+
+        if (count == 1)
+            name = JS_sprintf_append(name, "%s", array[0]->GetNameString());
+        else if (count == 2 && array[0] == isupp) {
+            name = JS_sprintf_append(name, "%s", array[1]->GetNameString());
+        } else {
+            for (uint16_t i = 0; i < count; i++) {
+                const char* fmt = (i == 0) ?
+                                    "(%s" : (i == count-1) ?
+                                        ", %s)" : ", %s";
+                name = JS_sprintf_append(name, fmt,
+                                         array[i]->GetNameString());
+            }
+        }
+    }
+
+    if (!name) {
+        return nullptr;
+    }
+    const char* fmt = "[xpconnect wrapped %s" FMT_ADDR FMT_STR(" (native")
+        FMT_ADDR FMT_STR(")") "]";
+    if (si) {
+        fmt = "[object %s" FMT_ADDR FMT_STR(" (native") FMT_ADDR FMT_STR(")") "]";
+    }
+    sz = JS_smprintf(fmt, name PARAM_ADDR(this) PARAM_ADDR(mIdentity.get()));
+
+    JS_smprintf_free(name);
+
+
+    return sz;
+
+#undef FMT_ADDR
+#undef PARAM_ADDR
+}
+
+/***************************************************************************/
+
+#ifdef XPC_CHECK_CLASSINFO_CLAIMS
+static void DEBUG_CheckClassInfoClaims(XPCWrappedNative* wrapper)
+{
+    if (!wrapper || !wrapper->GetClassInfo())
+        return;
+
+    nsISupports* obj = wrapper->GetIdentityObject();
+    XPCNativeSet* set = wrapper->GetSet();
+    uint16_t count = set->GetInterfaceCount();
+    for (uint16_t i = 0; i < count; i++) {
+        nsIClassInfo* clsInfo = wrapper->GetClassInfo();
+        XPCNativeInterface* iface = set->GetInterfaceAt(i);
+        nsIInterfaceInfo* info = iface->GetInterfaceInfo();
+        const nsIID* iid;
+        nsISupports* ptr;
+
+        info->GetIIDShared(&iid);
+        nsresult rv = obj->QueryInterface(*iid, (void**)&ptr);
+        if (NS_SUCCEEDED(rv)) {
+            NS_RELEASE(ptr);
+            continue;
+        }
+        if (rv == NS_ERROR_OUT_OF_MEMORY)
+            continue;
+
+        // Houston, We have a problem...
+
+        char* className = nullptr;
+        char* contractID = nullptr;
+        const char* interfaceName;
+
+        info->GetNameShared(&interfaceName);
+        clsInfo->GetContractID(&contractID);
+        if (wrapper->GetScriptableInfo()) {
+            wrapper->GetScriptableInfo()->GetCallback()->
+                GetClassName(&className);
+        }
+
+
+        printf("\n!!! Object's nsIClassInfo lies about its interfaces!!!\n"
+               "   classname: %s \n"
+               "   contractid: %s \n"
+               "   unimplemented interface name: %s\n\n",
+               className ? className : "<unknown>",
+               contractID ? contractID : "<unknown>",
+               interfaceName);
+
+        if (className)
+            free(className);
+        if (contractID)
+            free(contractID);
+    }
+}
+#endif
+
+NS_IMPL_ISUPPORTS(XPCJSObjectHolder, nsIXPConnectJSObjectHolder)
+
+JSObject*
+XPCJSObjectHolder::GetJSObject()
+{
+    NS_PRECONDITION(mJSObj, "bad object state");
+    return mJSObj;
+}
+
+XPCJSObjectHolder::XPCJSObjectHolder(JSObject* obj)
+    : mJSObj(obj)
+{
+    MOZ_ASSERT(obj);
+    XPCJSContext::Get()->AddObjectHolderRoot(this);
+}
+
+XPCJSObjectHolder::~XPCJSObjectHolder()
+{
+    RemoveFromRootSet();
+}
+
+void
+XPCJSObjectHolder::TraceJS(JSTracer* trc)
+{
+    JS::TraceEdge(trc, &mJSObj, "XPCJSObjectHolder::mJSObj");
+}
diff --git a/js/xpconnect/src/XPCWrappedNativeInfo.cpp b/js/xpconnect/src/XPCWrappedNativeInfo.cpp
new file mode 100644
index 000000000..302454fb5
--- /dev/null
+++ b/js/xpconnect/src/XPCWrappedNativeInfo.cpp
@@ -0,0 +1,800 @@
+/* -*- 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/. */
+
+/* Manage the shared info about interfaces for use by wrappedNatives. */
+
+#include "xpcprivate.h"
+#include "jswrapper.h"
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/XPTInterfaceInfoManager.h"
+#include "nsPrintfCString.h"
+
+using namespace JS;
+using namespace mozilla;
+
+/***************************************************************************/
+
+// XPCNativeMember
+
+// static
+bool
+XPCNativeMember::GetCallInfo(JSObject* funobj,
+                             RefPtr<XPCNativeInterface>* pInterface,
+                             XPCNativeMember**    pMember)
+{
+    funobj = js::UncheckedUnwrap(funobj);
+    Value memberVal =
+        js::GetFunctionNativeReserved(funobj,
+                                      XPC_FUNCTION_NATIVE_MEMBER_SLOT);
+
+    *pMember = static_cast<XPCNativeMember*>(memberVal.toPrivate());
+    *pInterface = (*pMember)->GetInterface();
+
+    return true;
+}
+
+bool
+XPCNativeMember::NewFunctionObject(XPCCallContext& ccx,
+                                   XPCNativeInterface* iface, HandleObject parent,
+                                   Value* pval)
+{
+    MOZ_ASSERT(!IsConstant(), "Only call this if you're sure this is not a constant!");
+
+    return Resolve(ccx, iface, parent, pval);
+}
+
+bool
+XPCNativeMember::Resolve(XPCCallContext& ccx, XPCNativeInterface* iface,
+                         HandleObject parent, Value* vp)
+{
+    MOZ_ASSERT(iface == GetInterface());
+    if (IsConstant()) {
+        RootedValue resultVal(ccx);
+        nsXPIDLCString name;
+        if (NS_FAILED(iface->GetInterfaceInfo()->GetConstant(mIndex, &resultVal,
+                                                             getter_Copies(name))))
+            return false;
+
+        *vp = resultVal;
+
+        return true;
+    }
+    // else...
+
+    // This is a method or attribute - we'll be needing a function object
+
+    int argc;
+    JSNative callback;
+
+    if (IsMethod()) {
+        const nsXPTMethodInfo* info;
+        if (NS_FAILED(iface->GetInterfaceInfo()->GetMethodInfo(mIndex, &info)))
+            return false;
+
+        // Note: ASSUMES that retval is last arg.
+        argc = (int) info->GetParamCount();
+        if (argc && info->GetParam((uint8_t)(argc-1)).IsRetval())
+            argc-- ;
+
+        callback = XPC_WN_CallMethod;
+    } else {
+        argc = 0;
+        callback = XPC_WN_GetterSetter;
+    }
+
+    JSFunction* fun = js::NewFunctionByIdWithReserved(ccx, callback, argc, 0, GetName());
+    if (!fun)
+        return false;
+
+    JSObject* funobj = JS_GetFunctionObject(fun);
+    if (!funobj)
+        return false;
+
+    js::SetFunctionNativeReserved(funobj, XPC_FUNCTION_NATIVE_MEMBER_SLOT,
+                                  PrivateValue(this));
+    js::SetFunctionNativeReserved(funobj, XPC_FUNCTION_PARENT_OBJECT_SLOT,
+                                  ObjectValue(*parent));
+
+    vp->setObject(*funobj);
+
+    return true;
+}
+
+/***************************************************************************/
+// XPCNativeInterface
+
+XPCNativeInterface::~XPCNativeInterface()
+{
+    XPCJSContext::Get()->GetIID2NativeInterfaceMap()->Remove(this);
+}
+
+// static
+already_AddRefed<XPCNativeInterface>
+XPCNativeInterface::GetNewOrUsed(const nsIID* iid)
+{
+    RefPtr<XPCNativeInterface> iface;
+    XPCJSContext* cx = XPCJSContext::Get();
+
+    IID2NativeInterfaceMap* map = cx->GetIID2NativeInterfaceMap();
+    if (!map)
+        return nullptr;
+
+    iface = map->Find(*iid);
+
+    if (iface)
+        return iface.forget();
+
+    nsCOMPtr<nsIInterfaceInfo> info;
+    XPTInterfaceInfoManager::GetSingleton()->GetInfoForIID(iid, getter_AddRefs(info));
+    if (!info)
+        return nullptr;
+
+    iface = NewInstance(info);
+    if (!iface)
+        return nullptr;
+
+    XPCNativeInterface* iface2 = map->Add(iface);
+    if (!iface2) {
+        NS_ERROR("failed to add our interface!");
+        iface = nullptr;
+    } else if (iface2 != iface) {
+        iface = iface2;
+    }
+
+    return iface.forget();
+}
+
+// static
+already_AddRefed<XPCNativeInterface>
+XPCNativeInterface::GetNewOrUsed(nsIInterfaceInfo* info)
+{
+    RefPtr<XPCNativeInterface> iface;
+
+    const nsIID* iid;
+    if (NS_FAILED(info->GetIIDShared(&iid)) || !iid)
+        return nullptr;
+
+    XPCJSContext* cx = XPCJSContext::Get();
+
+    IID2NativeInterfaceMap* map = cx->GetIID2NativeInterfaceMap();
+    if (!map)
+        return nullptr;
+
+    iface = map->Find(*iid);
+
+    if (iface)
+        return iface.forget();
+
+    iface = NewInstance(info);
+    if (!iface)
+        return nullptr;
+
+    RefPtr<XPCNativeInterface> iface2 = map->Add(iface);
+    if (!iface2) {
+        NS_ERROR("failed to add our interface!");
+        iface = nullptr;
+    } else if (iface2 != iface) {
+        iface = iface2;
+    }
+
+    return iface.forget();
+}
+
+// static
+already_AddRefed<XPCNativeInterface>
+XPCNativeInterface::GetNewOrUsed(const char* name)
+{
+    nsCOMPtr<nsIInterfaceInfo> info;
+    XPTInterfaceInfoManager::GetSingleton()->GetInfoForName(name, getter_AddRefs(info));
+    return info ? GetNewOrUsed(info) : nullptr;
+}
+
+// static
+already_AddRefed<XPCNativeInterface>
+XPCNativeInterface::GetISupports()
+{
+    // XXX We should optimize this to cache this common XPCNativeInterface.
+    return GetNewOrUsed(&NS_GET_IID(nsISupports));
+}
+
+// static
+already_AddRefed<XPCNativeInterface>
+XPCNativeInterface::NewInstance(nsIInterfaceInfo* aInfo)
+{
+    AutoJSContext cx;
+    static const uint16_t MAX_LOCAL_MEMBER_COUNT = 16;
+    XPCNativeMember local_members[MAX_LOCAL_MEMBER_COUNT];
+    RefPtr<XPCNativeInterface> obj;
+    XPCNativeMember* members = nullptr;
+
+    int i;
+    bool failed = false;
+    uint16_t constCount;
+    uint16_t methodCount;
+    uint16_t totalCount;
+    uint16_t realTotalCount = 0;
+    XPCNativeMember* cur;
+    RootedString str(cx);
+    RootedId interfaceName(cx);
+
+    // XXX Investigate lazy init? This is a problem given the
+    // 'placement new' scheme - we need to at least know how big to make
+    // the object. We might do a scan of methods to determine needed size,
+    // then make our object, but avoid init'ing *any* members until asked?
+    // Find out how often we create these objects w/o really looking at
+    // (or using) the members.
+
+    bool canScript;
+    if (NS_FAILED(aInfo->IsScriptable(&canScript)) || !canScript)
+        return nullptr;
+
+    bool mainProcessScriptableOnly;
+    if (NS_FAILED(aInfo->IsMainProcessScriptableOnly(&mainProcessScriptableOnly)))
+        return nullptr;
+    if (mainProcessScriptableOnly && !XRE_IsParentProcess()) {
+        nsCOMPtr<nsIConsoleService> console(do_GetService(NS_CONSOLESERVICE_CONTRACTID));
+        if (console) {
+            const char* intfNameChars;
+            aInfo->GetNameShared(&intfNameChars);
+            nsPrintfCString errorMsg("Use of %s in content process is deprecated.", intfNameChars);
+
+            nsAutoString filename;
+            uint32_t lineno = 0, column = 0;
+            nsJSUtils::GetCallingLocation(cx, filename, &lineno, &column);
+            nsCOMPtr<nsIScriptError> error(do_CreateInstance(NS_SCRIPTERROR_CONTRACTID));
+            error->Init(NS_ConvertUTF8toUTF16(errorMsg),
+                        filename, EmptyString(),
+                        lineno, column, nsIScriptError::warningFlag, "chrome javascript");
+            console->LogMessage(error);
+        }
+    }
+
+    if (NS_FAILED(aInfo->GetMethodCount(&methodCount)) ||
+        NS_FAILED(aInfo->GetConstantCount(&constCount)))
+        return nullptr;
+
+    // If the interface does not have nsISupports in its inheritance chain
+    // then we know we can't reflect its methods. However, some interfaces that
+    // are used just to reflect constants are declared this way. We need to
+    // go ahead and build the thing. But, we'll ignore whatever methods it may
+    // have.
+    if (!nsXPConnect::IsISupportsDescendant(aInfo))
+        methodCount = 0;
+
+    totalCount = methodCount + constCount;
+
+    if (totalCount > MAX_LOCAL_MEMBER_COUNT) {
+        members = new XPCNativeMember[totalCount];
+        if (!members)
+            return nullptr;
+    } else {
+        members = local_members;
+    }
+
+    // NOTE: since getters and setters share a member, we might not use all
+    // of the member objects.
+
+    for (i = 0; i < methodCount; i++) {
+        const nsXPTMethodInfo* info;
+        if (NS_FAILED(aInfo->GetMethodInfo(i, &info))) {
+            failed = true;
+            break;
+        }
+
+        // don't reflect Addref or Release
+        if (i == 1 || i == 2)
+            continue;
+
+        if (!XPCConvert::IsMethodReflectable(*info))
+            continue;
+
+        str = JS_AtomizeAndPinString(cx, info->GetName());
+        if (!str) {
+            NS_ERROR("bad method name");
+            failed = true;
+            break;
+        }
+        jsid name = INTERNED_STRING_TO_JSID(cx, str);
+
+        if (info->IsSetter()) {
+            MOZ_ASSERT(realTotalCount,"bad setter");
+            // Note: ASSUMES Getter/Setter pairs are next to each other
+            // This is a rule of the typelib spec.
+            cur = &members[realTotalCount-1];
+            MOZ_ASSERT(cur->GetName() == name,"bad setter");
+            MOZ_ASSERT(cur->IsReadOnlyAttribute(),"bad setter");
+            MOZ_ASSERT(cur->GetIndex() == i-1,"bad setter");
+            cur->SetWritableAttribute();
+        } else {
+            // XXX need better way to find dups
+            // MOZ_ASSERT(!LookupMemberByID(name),"duplicate method name");
+            if (realTotalCount == XPCNativeMember::GetMaxIndexInInterface()) {
+                NS_WARNING("Too many members in interface");
+                failed = true;
+                break;
+            }
+            cur = &members[realTotalCount];
+            cur->SetName(name);
+            if (info->IsGetter())
+                cur->SetReadOnlyAttribute(i);
+            else
+                cur->SetMethod(i);
+            cur->SetIndexInInterface(realTotalCount);
+            ++realTotalCount;
+        }
+    }
+
+    if (!failed) {
+        for (i = 0; i < constCount; i++) {
+            RootedValue constant(cx);
+            nsXPIDLCString namestr;
+            if (NS_FAILED(aInfo->GetConstant(i, &constant, getter_Copies(namestr)))) {
+                failed = true;
+                break;
+            }
+
+            str = JS_AtomizeAndPinString(cx, namestr);
+            if (!str) {
+                NS_ERROR("bad constant name");
+                failed = true;
+                break;
+            }
+            jsid name = INTERNED_STRING_TO_JSID(cx, str);
+
+            // XXX need better way to find dups
+            //MOZ_ASSERT(!LookupMemberByID(name),"duplicate method/constant name");
+            if (realTotalCount == XPCNativeMember::GetMaxIndexInInterface()) {
+                NS_WARNING("Too many members in interface");
+                failed = true;
+                break;
+            }
+            cur = &members[realTotalCount];
+            cur->SetName(name);
+            cur->SetConstant(i);
+            cur->SetIndexInInterface(realTotalCount);
+            ++realTotalCount;
+        }
+    }
+
+    if (!failed) {
+        const char* bytes;
+        if (NS_FAILED(aInfo->GetNameShared(&bytes)) || !bytes ||
+            nullptr == (str = JS_AtomizeAndPinString(cx, bytes))) {
+            failed = true;
+        }
+        interfaceName = INTERNED_STRING_TO_JSID(cx, str);
+    }
+
+    if (!failed) {
+        // Use placement new to create an object with the right amount of space
+        // to hold the members array
+        int size = sizeof(XPCNativeInterface);
+        if (realTotalCount > 1)
+            size += (realTotalCount - 1) * sizeof(XPCNativeMember);
+        void* place = new char[size];
+        if (place)
+            obj = new(place) XPCNativeInterface(aInfo, interfaceName);
+
+        if (obj) {
+            obj->mMemberCount = realTotalCount;
+            // copy valid members
+            if (realTotalCount)
+                memcpy(obj->mMembers, members,
+                       realTotalCount * sizeof(XPCNativeMember));
+        }
+    }
+
+    if (members && members != local_members)
+        delete [] members;
+
+    return obj.forget();
+}
+
+// static
+void
+XPCNativeInterface::DestroyInstance(XPCNativeInterface* inst)
+{
+    inst->~XPCNativeInterface();
+    delete [] (char*) inst;
+}
+
+size_t
+XPCNativeInterface::SizeOfIncludingThis(MallocSizeOf mallocSizeOf)
+{
+    return mallocSizeOf(this);
+}
+
+void
+XPCNativeInterface::DebugDump(int16_t depth)
+{
+#ifdef DEBUG
+    depth--;
+    XPC_LOG_ALWAYS(("XPCNativeInterface @ %x", this));
+        XPC_LOG_INDENT();
+        XPC_LOG_ALWAYS(("name is %s", GetNameString()));
+        XPC_LOG_ALWAYS(("mMemberCount is %d", mMemberCount));
+        XPC_LOG_ALWAYS(("mInfo @ %x", mInfo.get()));
+        XPC_LOG_OUTDENT();
+#endif
+}
+
+/***************************************************************************/
+// XPCNativeSetKey
+
+static PLDHashNumber
+HashPointer(const void* ptr)
+{
+    return NS_PTR_TO_UINT32(ptr) >> 2;
+}
+
+PLDHashNumber
+XPCNativeSetKey::Hash() const
+{
+    PLDHashNumber h = 0;
+
+    if (mBaseSet) {
+        XPCNativeInterface** current = mBaseSet->GetInterfaceArray();
+        uint16_t count = mBaseSet->GetInterfaceCount();
+        for (uint16_t i = 0; i < count; i++) {
+            h ^= HashPointer(*(current++));
+        }
+    } else {
+        // A newly created set will contain nsISupports first...
+        RefPtr<XPCNativeInterface> isupp = XPCNativeInterface::GetISupports();
+        h ^= HashPointer(isupp);
+
+        // ...but no more than once.
+        if (isupp == mAddition)
+            return h;
+    }
+
+    if (mAddition) {
+        h ^= HashPointer(mAddition);
+    }
+
+    return h;
+}
+
+/***************************************************************************/
+// XPCNativeSet
+
+XPCNativeSet::~XPCNativeSet()
+{
+    // Remove |this| before we clear the interfaces to ensure that the
+    // hashtable look up is correct.
+    XPCJSContext::Get()->GetNativeSetMap()->Remove(this);
+
+    for (int i = 0; i < mInterfaceCount; i++) {
+        NS_RELEASE(mInterfaces[i]);
+    }
+}
+
+// static
+already_AddRefed<XPCNativeSet>
+XPCNativeSet::GetNewOrUsed(const nsIID* iid)
+{
+    RefPtr<XPCNativeInterface> iface =
+        XPCNativeInterface::GetNewOrUsed(iid);
+    if (!iface)
+        return nullptr;
+
+    XPCNativeSetKey key(iface);
+
+    XPCJSContext* xpccx = XPCJSContext::Get();
+    NativeSetMap* map = xpccx->GetNativeSetMap();
+    if (!map)
+        return nullptr;
+
+    RefPtr<XPCNativeSet> set = map->Find(&key);
+
+    if (set)
+        return set.forget();
+
+    set = NewInstance({iface.forget()});
+    if (!set)
+        return nullptr;
+
+    if (!map->AddNew(&key, set)) {
+        NS_ERROR("failed to add our set!");
+        set = nullptr;
+    }
+
+    return set.forget();
+}
+
+// static
+already_AddRefed<XPCNativeSet>
+XPCNativeSet::GetNewOrUsed(nsIClassInfo* classInfo)
+{
+    XPCJSContext* xpccx = XPCJSContext::Get();
+    ClassInfo2NativeSetMap* map = xpccx->GetClassInfo2NativeSetMap();
+    if (!map)
+        return nullptr;
+
+    RefPtr<XPCNativeSet> set = map->Find(classInfo);
+
+    if (set)
+        return set.forget();
+
+    nsIID** iidArray = nullptr;
+    uint32_t iidCount = 0;
+
+    if (NS_FAILED(classInfo->GetInterfaces(&iidCount, &iidArray))) {
+        // Note: I'm making it OK for this call to fail so that one can add
+        // nsIClassInfo to classes implemented in script without requiring this
+        // method to be implemented.
+
+        // Make sure these are set correctly...
+        iidArray = nullptr;
+        iidCount = 0;
+    }
+
+    MOZ_ASSERT((iidCount && iidArray) || !(iidCount || iidArray), "GetInterfaces returned bad array");
+
+    // !!! from here on we only exit through the 'out' label !!!
+
+    if (iidCount) {
+        nsTArray<RefPtr<XPCNativeInterface>> interfaceArray(iidCount);
+        nsIID** currentIID = iidArray;
+
+        for (uint32_t i = 0; i < iidCount; i++) {
+            nsIID* iid = *(currentIID++);
+            if (!iid) {
+                NS_ERROR("Null found in classinfo interface list");
+                continue;
+            }
+
+            RefPtr<XPCNativeInterface> iface =
+                XPCNativeInterface::GetNewOrUsed(iid);
+
+            if (!iface) {
+                // XXX warn here
+                continue;
+            }
+
+            interfaceArray.AppendElement(iface.forget());
+        }
+
+        if (interfaceArray.Length() > 0) {
+            set = NewInstance(Move(interfaceArray));
+            if (set) {
+                NativeSetMap* map2 = xpccx->GetNativeSetMap();
+                if (!map2)
+                    goto out;
+
+                XPCNativeSetKey key(set);
+
+                XPCNativeSet* set2 = map2->Add(&key, set);
+                if (!set2) {
+                    NS_ERROR("failed to add our set!");
+                    set = nullptr;
+                    goto out;
+                }
+                // It is okay to find an existing entry here because
+                // we did not look for one before we called Add().
+                if (set2 != set) {
+                    set = set2;
+                }
+            }
+        } else
+            set = GetNewOrUsed(&NS_GET_IID(nsISupports));
+    } else
+        set = GetNewOrUsed(&NS_GET_IID(nsISupports));
+
+    if (set) {
+#ifdef DEBUG
+        XPCNativeSet* set2 =
+#endif
+          map->Add(classInfo, set);
+        MOZ_ASSERT(set2, "failed to add our set!");
+        MOZ_ASSERT(set2 == set, "hashtables inconsistent!");
+    }
+
+out:
+    if (iidArray)
+        NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(iidCount, iidArray);
+
+    return set.forget();
+}
+
+// static
+void
+XPCNativeSet::ClearCacheEntryForClassInfo(nsIClassInfo* classInfo)
+{
+    XPCJSContext* xpccx = nsXPConnect::GetContextInstance();
+    ClassInfo2NativeSetMap* map = xpccx->GetClassInfo2NativeSetMap();
+    if (map)
+        map->Remove(classInfo);
+}
+
+// static
+already_AddRefed<XPCNativeSet>
+XPCNativeSet::GetNewOrUsed(XPCNativeSetKey* key)
+{
+    NativeSetMap* map = XPCJSContext::Get()->GetNativeSetMap();
+    if (!map)
+        return nullptr;
+
+    RefPtr<XPCNativeSet> set = map->Find(key);
+
+    if (set)
+        return set.forget();
+
+    if (key->GetBaseSet())
+        set = NewInstanceMutate(key);
+    else
+        set = NewInstance({key->GetAddition()});
+
+    if (!set)
+        return nullptr;
+
+    if (!map->AddNew(key, set)) {
+        NS_ERROR("failed to add our set!");
+        set = nullptr;
+    }
+
+    return set.forget();
+}
+
+// static
+already_AddRefed<XPCNativeSet>
+XPCNativeSet::GetNewOrUsed(XPCNativeSet* firstSet,
+                           XPCNativeSet* secondSet,
+                           bool preserveFirstSetOrder)
+{
+    // Figure out how many interfaces we'll need in the new set.
+    uint32_t uniqueCount = firstSet->mInterfaceCount;
+    for (uint32_t i = 0; i < secondSet->mInterfaceCount; ++i) {
+        if (!firstSet->HasInterface(secondSet->mInterfaces[i]))
+            uniqueCount++;
+    }
+
+    // If everything in secondSet was a duplicate, we can just use the first
+    // set.
+    if (uniqueCount == firstSet->mInterfaceCount)
+        return RefPtr<XPCNativeSet>(firstSet).forget();
+
+    // If the secondSet is just a superset of the first, we can use it provided
+    // that the caller doesn't care about ordering.
+    if (!preserveFirstSetOrder && uniqueCount == secondSet->mInterfaceCount)
+        return RefPtr<XPCNativeSet>(secondSet).forget();
+
+    // Ok, darn. Now we have to make a new set.
+    //
+    // It would be faster to just create the new set all at once, but that
+    // would involve wrangling with some pretty hairy code - especially since
+    // a lot of stuff assumes that sets are created by adding one interface to an
+    // existing set. So let's just do the slow and easy thing and hope that the
+    // above optimizations handle the common cases.
+    RefPtr<XPCNativeSet> currentSet = firstSet;
+    for (uint32_t i = 0; i < secondSet->mInterfaceCount; ++i) {
+        XPCNativeInterface* iface = secondSet->mInterfaces[i];
+        if (!currentSet->HasInterface(iface)) {
+            // Create a new augmented set, inserting this interface at the end.
+            XPCNativeSetKey key(currentSet, iface);
+            currentSet = XPCNativeSet::GetNewOrUsed(&key);
+            if (!currentSet)
+                return nullptr;
+        }
+    }
+
+    // We've got the union set. Hand it back to the caller.
+    MOZ_ASSERT(currentSet->mInterfaceCount == uniqueCount);
+    return currentSet.forget();
+}
+
+// static
+already_AddRefed<XPCNativeSet>
+XPCNativeSet::NewInstance(nsTArray<RefPtr<XPCNativeInterface>>&& array)
+{
+    if (array.Length() == 0)
+        return nullptr;
+
+    // We impose the invariant:
+    // "All sets have exactly one nsISupports interface and it comes first."
+    // This is the place where we impose that rule - even if given inputs
+    // that don't exactly follow the rule.
+
+    RefPtr<XPCNativeInterface> isup = XPCNativeInterface::GetISupports();
+    uint16_t slots = array.Length() + 1;
+
+    for (auto key = array.begin(); key != array.end(); key++) {
+        if (*key == isup)
+            slots--;
+    }
+
+    // Use placement new to create an object with the right amount of space
+    // to hold the members array
+    int size = sizeof(XPCNativeSet);
+    if (slots > 1)
+        size += (slots - 1) * sizeof(XPCNativeInterface*);
+    void* place = new char[size];
+    RefPtr<XPCNativeSet> obj = new(place) XPCNativeSet();
+
+    // Stick the nsISupports in front and skip additional nsISupport(s)
+    XPCNativeInterface** outp = (XPCNativeInterface**) &obj->mInterfaces;
+    uint16_t memberCount = 1;   // for the one member in nsISupports
+
+    NS_ADDREF(*(outp++) = isup);
+
+    for (auto key = array.begin(); key != array.end(); key++) {
+        RefPtr<XPCNativeInterface> cur = key->forget();
+        if (isup == cur)
+            continue;
+        memberCount += cur->GetMemberCount();
+        *(outp++) = cur.forget().take();
+    }
+    obj->mMemberCount = memberCount;
+    obj->mInterfaceCount = slots;
+
+    return obj.forget();
+}
+
+// static
+already_AddRefed<XPCNativeSet>
+XPCNativeSet::NewInstanceMutate(XPCNativeSetKey* key)
+{
+    XPCNativeSet* otherSet = key->GetBaseSet();
+    XPCNativeInterface* newInterface = key->GetAddition();
+
+    MOZ_ASSERT(otherSet);
+
+    if (!newInterface)
+        return nullptr;
+
+    // Use placement new to create an object with the right amount of space
+    // to hold the members array
+    int size = sizeof(XPCNativeSet);
+    size += otherSet->mInterfaceCount * sizeof(XPCNativeInterface*);
+    void* place = new char[size];
+    RefPtr<XPCNativeSet> obj = new(place) XPCNativeSet();
+
+    obj->mMemberCount = otherSet->GetMemberCount() +
+        newInterface->GetMemberCount();
+    obj->mInterfaceCount = otherSet->mInterfaceCount + 1;
+
+    XPCNativeInterface** src = otherSet->mInterfaces;
+    XPCNativeInterface** dest = obj->mInterfaces;
+    for (uint16_t i = 0; i < otherSet->mInterfaceCount; i++) {
+        NS_ADDREF(*dest++ = *src++);
+    }
+    NS_ADDREF(*dest++ = newInterface);
+
+    return obj.forget();
+}
+
+// static
+void
+XPCNativeSet::DestroyInstance(XPCNativeSet* inst)
+{
+    inst->~XPCNativeSet();
+    delete [] (char*) inst;
+}
+
+size_t
+XPCNativeSet::SizeOfIncludingThis(MallocSizeOf mallocSizeOf)
+{
+    return mallocSizeOf(this);
+}
+
+void
+XPCNativeSet::DebugDump(int16_t depth)
+{
+#ifdef DEBUG
+    depth--;
+    XPC_LOG_ALWAYS(("XPCNativeSet @ %x", this));
+        XPC_LOG_INDENT();
+
+        XPC_LOG_ALWAYS(("mInterfaceCount of %d", mInterfaceCount));
+        if (depth) {
+            for (uint16_t i = 0; i < mInterfaceCount; i++)
+                mInterfaces[i]->DebugDump(depth);
+        }
+        XPC_LOG_ALWAYS(("mMemberCount of %d", mMemberCount));
+        XPC_LOG_OUTDENT();
+#endif
+}
diff --git a/js/xpconnect/src/XPCWrappedNativeJSOps.cpp b/js/xpconnect/src/XPCWrappedNativeJSOps.cpp
new file mode 100644
index 000000000..12b203b70
--- /dev/null
+++ b/js/xpconnect/src/XPCWrappedNativeJSOps.cpp
@@ -0,0 +1,1331 @@
+/* -*- 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/. */
+
+/* JavaScript JSClasses and JSOps for our Wrapped Native JS Objects. */
+
+#include "xpcprivate.h"
+#include "xpc_make_class.h"
+#include "jsprf.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/Preferences.h"
+#include "nsIAddonInterposition.h"
+#include "AddonWrapper.h"
+#include "js/Class.h"
+
+using namespace mozilla;
+using namespace JS;
+
+/***************************************************************************/
+
+// All of the exceptions thrown into JS from this file go through here.
+// That makes this a nice place to set a breakpoint.
+
+static bool Throw(nsresult errNum, JSContext* cx)
+{
+    XPCThrower::Throw(errNum, cx);
+    return false;
+}
+
+// Handy macro used in many callback stub below.
+
+#define THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper)                          \
+    PR_BEGIN_MACRO                                                            \
+    if (!wrapper)                                                             \
+        return Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);                    \
+    if (!wrapper->IsValid())                                                  \
+        return Throw(NS_ERROR_XPC_HAS_BEEN_SHUTDOWN, cx);                     \
+    PR_END_MACRO
+
+/***************************************************************************/
+
+static bool
+ToStringGuts(XPCCallContext& ccx)
+{
+    char* sz;
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+
+    if (wrapper)
+        sz = wrapper->ToString(ccx.GetTearOff());
+    else
+        sz = JS_smprintf("[xpconnect wrapped native prototype]");
+
+    if (!sz) {
+        JS_ReportOutOfMemory(ccx);
+        return false;
+    }
+
+    JSString* str = JS_NewStringCopyZ(ccx, sz);
+    JS_smprintf_free(sz);
+    if (!str)
+        return false;
+
+    ccx.SetRetVal(JS::StringValue(str));
+    return true;
+}
+
+/***************************************************************************/
+
+static bool
+XPC_WN_Shared_ToString(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    RootedObject obj(cx, JS_THIS_OBJECT(cx, vp));
+    if (!obj)
+        return false;
+
+    XPCCallContext ccx(cx, obj);
+    if (!ccx.IsValid())
+        return Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);
+    ccx.SetName(ccx.GetContext()->GetStringID(XPCJSContext::IDX_TO_STRING));
+    ccx.SetArgsAndResultPtr(args.length(), args.array(), vp);
+    return ToStringGuts(ccx);
+}
+
+static bool
+XPC_WN_Shared_ToSource(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    static const char empty[] = "({})";
+    JSString* str = JS_NewStringCopyN(cx, empty, sizeof(empty)-1);
+    if (!str)
+        return false;
+    args.rval().setString(str);
+
+    return true;
+}
+
+static bool
+XPC_WN_Shared_toPrimitive(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    RootedObject obj(cx);
+    if (!JS_ValueToObject(cx, args.thisv(), &obj))
+        return false;
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    JSType hint;
+    if (!GetFirstArgumentAsTypeHint(cx, args, &hint))
+        return false;
+
+    if (hint == JSTYPE_NUMBER) {
+        args.rval().set(JS_GetNaNValue(cx));
+        return true;
+    }
+
+    MOZ_ASSERT(hint == JSTYPE_STRING || hint == JSTYPE_VOID);
+    ccx.SetName(ccx.GetContext()->GetStringID(XPCJSContext::IDX_TO_STRING));
+    ccx.SetArgsAndResultPtr(0, nullptr, args.rval().address());
+
+    XPCNativeMember* member = ccx.GetMember();
+    if (member && member->IsMethod()) {
+        if (!XPCWrappedNative::CallMethod(ccx))
+            return false;
+
+        if (args.rval().isPrimitive())
+            return true;
+    }
+
+    // else...
+    return ToStringGuts(ccx);
+}
+
+/***************************************************************************/
+
+// A "double wrapped object" is a user JSObject that has been wrapped as a
+// wrappedJS in order to be used by native code and then re-wrapped by a
+// wrappedNative wrapper to be used by JS code. One might think of it as:
+//    wrappedNative(wrappedJS(underlying_JSObject))
+// This is done (as opposed to just unwrapping the wrapped JS and automatically
+// returning the underlying JSObject) so that JS callers will see what looks
+// Like any other xpcom object - and be limited to use its interfaces.
+//
+// See the comment preceding nsIXPCWrappedJSObjectGetter in nsIXPConnect.idl.
+
+static JSObject*
+GetDoubleWrappedJSObject(XPCCallContext& ccx, XPCWrappedNative* wrapper)
+{
+    RootedObject obj(ccx);
+    nsCOMPtr<nsIXPConnectWrappedJS>
+        underware = do_QueryInterface(wrapper->GetIdentityObject());
+    if (underware) {
+        RootedObject mainObj(ccx, underware->GetJSObject());
+        if (mainObj) {
+            RootedId id(ccx, ccx.GetContext()->
+                            GetStringID(XPCJSContext::IDX_WRAPPED_JSOBJECT));
+
+            JSAutoCompartment ac(ccx, mainObj);
+
+            RootedValue val(ccx);
+            if (JS_GetPropertyById(ccx, mainObj, id, &val) &&
+                !val.isPrimitive()) {
+                obj = val.toObjectOrNull();
+            }
+        }
+    }
+    return obj;
+}
+
+// This is the getter native function we use to handle 'wrappedJSObject' for
+// double wrapped JSObjects.
+
+static bool
+XPC_WN_DoubleWrappedGetter(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+
+    RootedObject obj(cx, JS_THIS_OBJECT(cx, vp));
+    if (!obj)
+        return false;
+
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    MOZ_ASSERT(JS_TypeOfValue(cx, args.calleev()) == JSTYPE_FUNCTION, "bad function");
+
+    RootedObject realObject(cx, GetDoubleWrappedJSObject(ccx, wrapper));
+    if (!realObject) {
+        // This is pretty unexpected at this point. The object originally
+        // responded to this get property call and now gives no object.
+        // XXX Should this throw something at the caller?
+        args.rval().setNull();
+        return true;
+    }
+
+    // It is a double wrapped object. This should really never appear in
+    // content these days, but addons still do it - see bug 965921.
+    if (MOZ_UNLIKELY(!nsContentUtils::IsCallerChrome())) {
+        JS_ReportErrorASCII(cx, "Attempt to use .wrappedJSObject in untrusted code");
+        return false;
+    }
+    args.rval().setObject(*realObject);
+    return JS_WrapValue(cx, args.rval());
+}
+
+/***************************************************************************/
+
+// This is our shared function to define properties on our JSObjects.
+
+/*
+ * NOTE:
+ * We *never* set the tearoff names (e.g. nsIFoo) as JS_ENUMERATE.
+ * We *never* set toString or toSource as JS_ENUMERATE.
+ */
+
+static bool
+DefinePropertyIfFound(XPCCallContext& ccx,
+                      HandleObject obj,
+                      HandleId idArg,
+                      XPCNativeSet* set,
+                      XPCNativeInterface* ifaceArg,
+                      XPCNativeMember* member,
+                      XPCWrappedNativeScope* scope,
+                      bool reflectToStringAndToSource,
+                      XPCWrappedNative* wrapperToReflectInterfaceNames,
+                      XPCWrappedNative* wrapperToReflectDoubleWrap,
+                      XPCNativeScriptableInfo* scriptableInfo,
+                      unsigned propFlags,
+                      bool* resolved)
+{
+    RootedId id(ccx, idArg);
+    RefPtr<XPCNativeInterface> iface = ifaceArg;
+    XPCJSContext* xpccx = ccx.GetContext();
+    bool found;
+    const char* name;
+
+    propFlags |= JSPROP_RESOLVING;
+
+    if (set) {
+        if (iface)
+            found = true;
+        else
+            found = set->FindMember(id, &member, &iface);
+    } else
+        found = (nullptr != (member = iface->FindMember(id)));
+
+    if (!found) {
+        if (reflectToStringAndToSource) {
+            JSNative call;
+            uint32_t flags = 0;
+
+            if (scriptableInfo) {
+                nsCOMPtr<nsIClassInfo> classInfo = do_QueryInterface(
+                    scriptableInfo->GetCallback());
+
+                if (classInfo) {
+                    nsresult rv = classInfo->GetFlags(&flags);
+                    if (NS_FAILED(rv))
+                        return Throw(rv, ccx);
+                }
+            }
+
+            bool overwriteToString = !(flags & nsIClassInfo::DOM_OBJECT)
+                || Preferences::GetBool("dom.XPCToStringForDOMClasses", false);
+
+            if(id == xpccx->GetStringID(XPCJSContext::IDX_TO_STRING)
+                && overwriteToString)
+            {
+                call = XPC_WN_Shared_ToString;
+                name = xpccx->GetStringName(XPCJSContext::IDX_TO_STRING);
+            } else if (id == xpccx->GetStringID(XPCJSContext::IDX_TO_SOURCE)) {
+                call = XPC_WN_Shared_ToSource;
+                name = xpccx->GetStringName(XPCJSContext::IDX_TO_SOURCE);
+            } else if (id == SYMBOL_TO_JSID(
+                               JS::GetWellKnownSymbol(ccx, JS::SymbolCode::toPrimitive)))
+            {
+                call = XPC_WN_Shared_toPrimitive;
+                name = "[Symbol.toPrimitive]";
+            } else {
+                call = nullptr;
+            }
+
+            if (call) {
+                RootedFunction fun(ccx, JS_NewFunction(ccx, call, 0, 0, name));
+                if (!fun) {
+                    JS_ReportOutOfMemory(ccx);
+                    return false;
+                }
+
+                AutoResolveName arn(ccx, id);
+                if (resolved)
+                    *resolved = true;
+                RootedObject value(ccx, JS_GetFunctionObject(fun));
+                return JS_DefinePropertyById(ccx, obj, id, value,
+                                             propFlags & ~JSPROP_ENUMERATE);
+            }
+        }
+        // This *might* be a tearoff name that is not yet part of our
+        // set. Let's lookup the name and see if it is the name of an
+        // interface. Then we'll see if the object actually *does* this
+        // interface and add a tearoff as necessary.
+
+        if (wrapperToReflectInterfaceNames) {
+            JSAutoByteString name;
+            RefPtr<XPCNativeInterface> iface2;
+            XPCWrappedNativeTearOff* to;
+            RootedObject jso(ccx);
+            nsresult rv = NS_OK;
+
+            if (JSID_IS_STRING(id) &&
+                name.encodeLatin1(ccx, JSID_TO_STRING(id)) &&
+                (iface2 = XPCNativeInterface::GetNewOrUsed(name.ptr()), iface2) &&
+                nullptr != (to = wrapperToReflectInterfaceNames->
+                           FindTearOff(iface2, true, &rv)) &&
+                nullptr != (jso = to->GetJSObject()))
+
+            {
+                AutoResolveName arn(ccx, id);
+                if (resolved)
+                    *resolved = true;
+                return JS_DefinePropertyById(ccx, obj, id, jso,
+                                             propFlags & ~JSPROP_ENUMERATE);
+            } else if (NS_FAILED(rv) && rv != NS_ERROR_NO_INTERFACE) {
+                return Throw(rv, ccx);
+            }
+        }
+
+        // This *might* be a double wrapped JSObject
+        if (wrapperToReflectDoubleWrap &&
+            id == xpccx->GetStringID(XPCJSContext::IDX_WRAPPED_JSOBJECT) &&
+            GetDoubleWrappedJSObject(ccx, wrapperToReflectDoubleWrap)) {
+            // We build and add a getter function.
+            // A security check is done on a per-get basis.
+
+            JSFunction* fun;
+
+            id = xpccx->GetStringID(XPCJSContext::IDX_WRAPPED_JSOBJECT);
+            name = xpccx->GetStringName(XPCJSContext::IDX_WRAPPED_JSOBJECT);
+
+            fun = JS_NewFunction(ccx, XPC_WN_DoubleWrappedGetter,
+                                 0, 0, name);
+
+            if (!fun)
+                return false;
+
+            RootedObject funobj(ccx, JS_GetFunctionObject(fun));
+            if (!funobj)
+                return false;
+
+            propFlags |= JSPROP_GETTER | JSPROP_SHARED;
+            propFlags &= ~JSPROP_ENUMERATE;
+
+            AutoResolveName arn(ccx, id);
+            if (resolved)
+                *resolved = true;
+            return JS_DefinePropertyById(ccx, obj, id, UndefinedHandleValue, propFlags,
+                                         JS_DATA_TO_FUNC_PTR(JSNative, funobj.get()),
+                                         nullptr);
+        }
+
+        if (resolved)
+            *resolved = false;
+        return true;
+    }
+
+    if (!member) {
+        if (wrapperToReflectInterfaceNames) {
+            XPCWrappedNativeTearOff* to =
+              wrapperToReflectInterfaceNames->FindTearOff(iface, true);
+
+            if (!to)
+                return false;
+            RootedObject jso(ccx, to->GetJSObject());
+            if (!jso)
+                return false;
+
+            AutoResolveName arn(ccx, id);
+            if (resolved)
+                *resolved = true;
+            return JS_DefinePropertyById(ccx, obj, id, jso,
+                                         propFlags & ~JSPROP_ENUMERATE);
+        }
+        if (resolved)
+            *resolved = false;
+        return true;
+    }
+
+    if (member->IsConstant()) {
+        RootedValue val(ccx);
+        AutoResolveName arn(ccx, id);
+        if (resolved)
+            *resolved = true;
+        return member->GetConstantValue(ccx, iface, val.address()) &&
+               JS_DefinePropertyById(ccx, obj, id, val, propFlags);
+    }
+
+    if (scope->HasInterposition()) {
+        Rooted<PropertyDescriptor> desc(ccx);
+        if (!xpc::InterposeProperty(ccx, obj, iface->GetIID(), id, &desc))
+            return false;
+
+        if (desc.object()) {
+            AutoResolveName arn(ccx, id);
+            if (resolved)
+                *resolved = true;
+            desc.attributesRef() |= JSPROP_RESOLVING;
+            return JS_DefinePropertyById(ccx, obj, id, desc);
+        }
+    }
+
+    if (id == xpccx->GetStringID(XPCJSContext::IDX_TO_STRING) ||
+        id == xpccx->GetStringID(XPCJSContext::IDX_TO_SOURCE) ||
+        (scriptableInfo &&
+         scriptableInfo->GetFlags().DontEnumQueryInterface() &&
+         id == xpccx->GetStringID(XPCJSContext::IDX_QUERY_INTERFACE)))
+        propFlags &= ~JSPROP_ENUMERATE;
+
+    RootedValue funval(ccx);
+    if (!member->NewFunctionObject(ccx, iface, obj, funval.address()))
+        return false;
+
+    if (member->IsMethod()) {
+        AutoResolveName arn(ccx, id);
+        if (resolved)
+            *resolved = true;
+        return JS_DefinePropertyById(ccx, obj, id, funval, propFlags);
+    }
+
+    // else...
+
+    MOZ_ASSERT(member->IsAttribute(), "way broken!");
+
+    propFlags |= JSPROP_GETTER | JSPROP_SHARED;
+    propFlags &= ~JSPROP_READONLY;
+    JSObject* funobj = funval.toObjectOrNull();
+    JSNative getter = JS_DATA_TO_FUNC_PTR(JSNative, funobj);
+    JSNative setter;
+    if (member->IsWritableAttribute()) {
+        propFlags |= JSPROP_SETTER;
+        setter = JS_DATA_TO_FUNC_PTR(JSNative, funobj);
+    } else {
+        setter = nullptr;
+    }
+
+    AutoResolveName arn(ccx, id);
+    if (resolved)
+        *resolved = true;
+
+    return JS_DefinePropertyById(ccx, obj, id, UndefinedHandleValue, propFlags, getter, setter);
+}
+
+/***************************************************************************/
+/***************************************************************************/
+
+static bool
+XPC_WN_OnlyIWrite_AddPropertyStub(JSContext* cx, HandleObject obj, HandleId id, HandleValue v)
+{
+    XPCCallContext ccx(cx, obj, nullptr, id);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    // Allow only XPConnect to add/set the property
+    if (ccx.GetResolveName() == id)
+        return true;
+
+    return Throw(NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN, cx);
+}
+
+bool
+XPC_WN_CannotModifyPropertyStub(JSContext* cx, HandleObject obj, HandleId id,
+                                HandleValue v)
+{
+    return Throw(NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN, cx);
+}
+
+bool
+XPC_WN_CantDeletePropertyStub(JSContext* cx, HandleObject obj, HandleId id,
+                              ObjectOpResult& result)
+{
+    return Throw(NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN, cx);
+}
+
+bool
+XPC_WN_CannotModifySetPropertyStub(JSContext* cx, HandleObject obj, HandleId id,
+                                   MutableHandleValue vp, ObjectOpResult& result)
+{
+    return Throw(NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN, cx);
+}
+
+bool
+XPC_WN_Shared_Enumerate(JSContext* cx, HandleObject obj)
+{
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    // Since we aren't going to enumerate tearoff names and the prototype
+    // handles non-mutated members, we can do this potential short-circuit.
+    if (!wrapper->HasMutatedSet())
+        return true;
+
+    XPCNativeSet* set = wrapper->GetSet();
+    XPCNativeSet* protoSet = wrapper->HasProto() ?
+                                wrapper->GetProto()->GetSet() : nullptr;
+
+    uint16_t interface_count = set->GetInterfaceCount();
+    XPCNativeInterface** interfaceArray = set->GetInterfaceArray();
+    for (uint16_t i = 0; i < interface_count; i++) {
+        XPCNativeInterface* iface = interfaceArray[i];
+        uint16_t member_count = iface->GetMemberCount();
+        for (uint16_t k = 0; k < member_count; k++) {
+            XPCNativeMember* member = iface->GetMemberAt(k);
+            jsid name = member->GetName();
+
+            // Skip if this member is going to come from the proto.
+            uint16_t index;
+            if (protoSet &&
+                protoSet->FindMember(name, nullptr, &index) && index == i)
+                continue;
+            if (!xpc_ForcePropertyResolve(cx, obj, name))
+                return false;
+        }
+    }
+    return true;
+}
+
+/***************************************************************************/
+
+enum WNHelperType {
+    WN_NOHELPER,
+    WN_HELPER
+};
+
+static void
+WrappedNativeFinalize(js::FreeOp* fop, JSObject* obj, WNHelperType helperType)
+{
+    const js::Class* clazz = js::GetObjectClass(obj);
+    if (clazz->flags & JSCLASS_DOM_GLOBAL) {
+        mozilla::dom::DestroyProtoAndIfaceCache(obj);
+    }
+    nsISupports* p = static_cast<nsISupports*>(xpc_GetJSPrivate(obj));
+    if (!p)
+        return;
+
+    XPCWrappedNative* wrapper = static_cast<XPCWrappedNative*>(p);
+    if (helperType == WN_HELPER)
+        wrapper->GetScriptableCallback()->Finalize(wrapper, js::CastToJSFreeOp(fop), obj);
+    wrapper->FlatJSObjectFinalized();
+}
+
+static void
+WrappedNativeObjectMoved(JSObject* obj, const JSObject* old)
+{
+    nsISupports* p = static_cast<nsISupports*>(xpc_GetJSPrivate(obj));
+    if (!p)
+        return;
+
+    XPCWrappedNative* wrapper = static_cast<XPCWrappedNative*>(p);
+    wrapper->FlatJSObjectMoved(obj, old);
+}
+
+void
+XPC_WN_NoHelper_Finalize(js::FreeOp* fop, JSObject* obj)
+{
+    WrappedNativeFinalize(fop, obj, WN_NOHELPER);
+}
+
+/*
+ * General comment about XPConnect tracing: Given a C++ object |wrapper| and its
+ * corresponding JS object |obj|, calling |wrapper->TraceSelf| will ask the JS
+ * engine to mark |obj|. Eventually, this will lead to the trace hook being
+ * called for |obj|. The trace hook should call |wrapper->TraceInside|, which
+ * should mark any JS objects held by |wrapper| as members.
+ */
+
+/* static */ void
+XPCWrappedNative::Trace(JSTracer* trc, JSObject* obj)
+{
+    const js::Class* clazz = js::GetObjectClass(obj);
+    if (clazz->flags & JSCLASS_DOM_GLOBAL) {
+        mozilla::dom::TraceProtoAndIfaceCache(trc, obj);
+    }
+    MOZ_ASSERT(IS_WN_CLASS(clazz));
+
+    XPCWrappedNative* wrapper = XPCWrappedNative::Get(obj);
+    if (wrapper && wrapper->IsValid())
+        wrapper->TraceInside(trc);
+}
+
+void
+XPCWrappedNative_Trace(JSTracer* trc, JSObject* obj)
+{
+    XPCWrappedNative::Trace(trc, obj);
+}
+
+static bool
+XPC_WN_NoHelper_Resolve(JSContext* cx, HandleObject obj, HandleId id, bool* resolvedp)
+{
+    XPCCallContext ccx(cx, obj, nullptr, id);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    XPCNativeSet* set = ccx.GetSet();
+    if (!set)
+        return true;
+
+    // Don't resolve properties that are on our prototype.
+    if (ccx.GetInterface() && !ccx.GetStaticMemberIsLocal())
+        return true;
+
+    return DefinePropertyIfFound(ccx, obj, id,
+                                 set, nullptr, nullptr, wrapper->GetScope(),
+                                 true, wrapper, wrapper, nullptr,
+                                 JSPROP_ENUMERATE |
+                                 JSPROP_READONLY |
+                                 JSPROP_PERMANENT,
+                                 resolvedp);
+}
+
+static const js::ClassOps XPC_WN_NoHelper_JSClassOps = {
+    XPC_WN_OnlyIWrite_AddPropertyStub, // addProperty
+    XPC_WN_CantDeletePropertyStub,     // delProperty
+    nullptr,                           // getProperty
+    nullptr,                           // setProperty
+    XPC_WN_Shared_Enumerate,           // enumerate
+    XPC_WN_NoHelper_Resolve,           // resolve
+    nullptr,                           // mayResolve
+    XPC_WN_NoHelper_Finalize,          // finalize
+    nullptr,                           // call
+    nullptr,                           // construct
+    nullptr,                           // hasInstance
+    XPCWrappedNative::Trace,           // trace
+};
+
+const js::ClassExtension XPC_WN_JSClassExtension = {
+    nullptr, // weakmapKeyDelegateOp
+    WrappedNativeObjectMoved
+};
+
+const js::Class XPC_WN_NoHelper_JSClass = {
+    "XPCWrappedNative_NoHelper",
+    XPC_WRAPPER_FLAGS |
+    JSCLASS_IS_WRAPPED_NATIVE |
+    JSCLASS_PRIVATE_IS_NSISUPPORTS |
+    JSCLASS_FOREGROUND_FINALIZE,
+    &XPC_WN_NoHelper_JSClassOps,
+    JS_NULL_CLASS_SPEC,
+    &XPC_WN_JSClassExtension,
+    JS_NULL_OBJECT_OPS
+};
+
+
+/***************************************************************************/
+
+bool
+XPC_WN_MaybeResolvingPropertyStub(JSContext* cx, HandleObject obj, HandleId id, HandleValue v)
+{
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    if (ccx.GetResolvingWrapper() == wrapper)
+        return true;
+    return Throw(NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN, cx);
+}
+
+bool
+XPC_WN_MaybeResolvingSetPropertyStub(JSContext* cx, HandleObject obj, HandleId id,
+                                     MutableHandleValue vp, ObjectOpResult& result)
+{
+    result.succeed();
+    return XPC_WN_MaybeResolvingPropertyStub(cx, obj, id, vp);
+}
+
+bool
+XPC_WN_MaybeResolvingDeletePropertyStub(JSContext* cx, HandleObject obj, HandleId id,
+                                        ObjectOpResult& result)
+{
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    if (ccx.GetResolvingWrapper() == wrapper) {
+        return result.succeed();
+    }
+    return Throw(NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN, cx);
+}
+
+// macro fun!
+#define PRE_HELPER_STUB                                                       \
+    /* It's very important for "unwrapped" to be rooted here.  */             \
+    RootedObject unwrapped(cx, js::CheckedUnwrap(obj, false));                \
+    if (!unwrapped) {                                                         \
+        JS_ReportErrorASCII(cx, "Permission denied to operate on object.");   \
+        return false;                                                         \
+    }                                                                         \
+    if (!IS_WN_REFLECTOR(unwrapped)) {                                        \
+        return Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);                    \
+    }                                                                         \
+    XPCWrappedNative* wrapper = XPCWrappedNative::Get(unwrapped);             \
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);                             \
+    bool retval = true;                                                       \
+    nsresult rv = wrapper->GetScriptableCallback()->
+
+#define POST_HELPER_STUB                                                      \
+    if (NS_FAILED(rv))                                                        \
+        return Throw(rv, cx);                                                 \
+    return retval;
+
+#define POST_HELPER_STUB_WITH_OBJECTOPRESULT(failMethod)                      \
+    if (NS_FAILED(rv))                                                        \
+        return Throw(rv, cx);                                                 \
+    return retval ? result.succeed() : result.failMethod();
+
+bool
+XPC_WN_Helper_GetProperty(JSContext* cx, HandleObject obj, HandleId id,
+                          MutableHandleValue vp)
+{
+    PRE_HELPER_STUB
+    GetProperty(wrapper, cx, obj, id, vp.address(), &retval);
+    POST_HELPER_STUB
+}
+
+bool
+XPC_WN_Helper_SetProperty(JSContext* cx, HandleObject obj, HandleId id,
+                          MutableHandleValue vp, ObjectOpResult& result)
+{
+    PRE_HELPER_STUB
+    SetProperty(wrapper, cx, obj, id, vp.address(), &retval);
+    POST_HELPER_STUB_WITH_OBJECTOPRESULT(failReadOnly)
+}
+
+bool
+XPC_WN_Helper_Call(JSContext* cx, unsigned argc, Value* vp)
+{
+    JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+    // N.B. we want obj to be the callee, not JS_THIS(cx, vp)
+    RootedObject obj(cx, &args.callee());
+
+    XPCCallContext ccx(cx, obj, nullptr, JSID_VOIDHANDLE, args.length(),
+                       args.array(), args.rval().address());
+    if (!ccx.IsValid())
+        return false;
+
+    PRE_HELPER_STUB
+    Call(wrapper, cx, obj, args, &retval);
+    POST_HELPER_STUB
+}
+
+bool
+XPC_WN_Helper_Construct(JSContext* cx, unsigned argc, Value* vp)
+{
+    JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+    RootedObject obj(cx, &args.callee());
+    if (!obj)
+        return false;
+
+    XPCCallContext ccx(cx, obj, nullptr, JSID_VOIDHANDLE, args.length(),
+                       args.array(), args.rval().address());
+    if (!ccx.IsValid())
+        return false;
+
+    PRE_HELPER_STUB
+    Construct(wrapper, cx, obj, args, &retval);
+    POST_HELPER_STUB
+}
+
+bool
+XPC_WN_Helper_HasInstance(JSContext* cx, HandleObject obj, MutableHandleValue valp, bool* bp)
+{
+    bool retval2;
+    PRE_HELPER_STUB
+    HasInstance(wrapper, cx, obj, valp, &retval2, &retval);
+    *bp = retval2;
+    POST_HELPER_STUB
+}
+
+void
+XPC_WN_Helper_Finalize(js::FreeOp* fop, JSObject* obj)
+{
+    WrappedNativeFinalize(fop, obj, WN_HELPER);
+}
+
+bool
+XPC_WN_Helper_Resolve(JSContext* cx, HandleObject obj, HandleId id, bool* resolvedp)
+{
+    nsresult rv = NS_OK;
+    bool retval = true;
+    bool resolved = false;
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    RootedId old(cx, ccx.SetResolveName(id));
+
+    XPCNativeScriptableInfo* si = wrapper->GetScriptableInfo();
+    if (si && si->GetFlags().WantResolve()) {
+        XPCWrappedNative* oldResolvingWrapper;
+        bool allowPropMods = si->GetFlags().AllowPropModsDuringResolve();
+
+        if (allowPropMods)
+            oldResolvingWrapper = ccx.SetResolvingWrapper(wrapper);
+
+        rv = si->GetCallback()->Resolve(wrapper, cx, obj, id, &resolved, &retval);
+
+        if (allowPropMods)
+            (void)ccx.SetResolvingWrapper(oldResolvingWrapper);
+    }
+
+    old = ccx.SetResolveName(old);
+    MOZ_ASSERT(old == id, "bad nest");
+
+    if (NS_FAILED(rv)) {
+        return Throw(rv, cx);
+    }
+
+    if (resolved) {
+        *resolvedp = true;
+    } else if (wrapper->HasMutatedSet()) {
+        // We are here if scriptable did not resolve this property and
+        // it *might* be in the instance set but not the proto set.
+
+        XPCNativeSet* set = wrapper->GetSet();
+        XPCNativeSet* protoSet = wrapper->HasProto() ?
+                                    wrapper->GetProto()->GetSet() : nullptr;
+        XPCNativeMember* member = nullptr;
+        RefPtr<XPCNativeInterface> iface;
+        bool IsLocal = false;
+
+        if (set->FindMember(id, &member, &iface, protoSet, &IsLocal) &&
+            IsLocal) {
+            XPCWrappedNative* oldResolvingWrapper;
+
+            XPCNativeScriptableFlags siFlags(0);
+            if (si)
+                siFlags = si->GetFlags();
+
+            XPCWrappedNative* wrapperForInterfaceNames =
+                siFlags.DontReflectInterfaceNames() ? nullptr : wrapper;
+
+            oldResolvingWrapper = ccx.SetResolvingWrapper(wrapper);
+            retval = DefinePropertyIfFound(ccx, obj, id,
+                                           set, iface, member,
+                                           wrapper->GetScope(),
+                                           false,
+                                           wrapperForInterfaceNames,
+                                           nullptr, si,
+                                           JSPROP_ENUMERATE, resolvedp);
+            (void)ccx.SetResolvingWrapper(oldResolvingWrapper);
+        }
+    }
+
+    return retval;
+}
+
+bool
+XPC_WN_Helper_Enumerate(JSContext* cx, HandleObject obj)
+{
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    XPCNativeScriptableInfo* si = wrapper->GetScriptableInfo();
+    if (!si || !si->GetFlags().WantEnumerate())
+        return Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);
+
+    if (!XPC_WN_Shared_Enumerate(cx, obj))
+        return false;
+
+    bool retval = true;
+    nsresult rv = si->GetCallback()->Enumerate(wrapper, cx, obj, &retval);
+    if (NS_FAILED(rv))
+        return Throw(rv, cx);
+    return retval;
+}
+
+/***************************************************************************/
+
+static bool
+XPC_WN_JSOp_Enumerate(JSContext* cx, HandleObject obj, AutoIdVector& properties,
+                      bool enumerableOnly)
+{
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    XPCNativeScriptableInfo* si = wrapper->GetScriptableInfo();
+    if (!si || !si->GetFlags().WantNewEnumerate())
+        return Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);
+
+    if (!XPC_WN_Shared_Enumerate(cx, obj))
+        return false;
+
+    bool retval = true;
+    nsresult rv = si->GetCallback()->NewEnumerate(wrapper, cx, obj, properties, &retval);
+    if (NS_FAILED(rv))
+        return Throw(rv, cx);
+    return retval;
+}
+
+/***************************************************************************/
+
+// static
+XPCNativeScriptableInfo*
+XPCNativeScriptableInfo::Construct(const XPCNativeScriptableCreateInfo* sci)
+{
+    MOZ_ASSERT(sci, "bad param");
+    nsCOMPtr<nsIXPCScriptable> callback = sci->GetCallback();
+    MOZ_ASSERT(callback);
+    MOZ_ASSERT(callback->GetScriptableFlags() == sci->GetFlags());
+    return new XPCNativeScriptableInfo(callback);
+}
+
+const js::ObjectOps XPC_WN_ObjectOpsWithEnumerate = {
+    nullptr,  // lookupProperty
+    nullptr,  // defineProperty
+    nullptr,  // hasProperty
+    nullptr,  // getProperty
+    nullptr,  // setProperty
+    nullptr,  // getOwnPropertyDescriptor
+    nullptr,  // deleteProperty
+    nullptr,  // watch
+    nullptr,  // unwatch
+    nullptr,  // getElements
+    XPC_WN_JSOp_Enumerate,
+    nullptr,  // funToString
+};
+
+/***************************************************************************/
+/***************************************************************************/
+
+// Compatibility hack.
+//
+// XPConnect used to do all sorts of funny tricks to find the "correct"
+// |this| object for a given method (often to the detriment of proper
+// call/apply). When these tricks were removed, a fair amount of chrome
+// code broke, because it was relying on being able to grab methods off
+// some XPCOM object (like the nsITelemetry service) and invoke them without
+// a proper |this|. So, if it's quite clear that we're in this situation and
+// about to use a |this| argument that just won't work, fix things up.
+//
+// This hack is only useful for getters/setters if someone sets an XPCOM object
+// as the prototype for a vanilla JS object and expects the XPCOM attributes to
+// work on the derived object, which we really don't want to support. But we
+// handle it anyway, for now, to minimize regression risk on an already-risky
+// landing.
+//
+// This hack is mainly useful for the NoHelper JSClass. We also fix up
+// Components.utils because it implements nsIXPCScriptable (giving it a custom
+// JSClass) but not nsIClassInfo (which would put the methods on a prototype).
+
+#define IS_NOHELPER_CLASS(clasp) (clasp == &XPC_WN_NoHelper_JSClass)
+#define IS_CU_CLASS(clasp) (clasp->name[0] == 'n' && !strcmp(clasp->name, "nsXPCComponents_Utils"))
+
+MOZ_ALWAYS_INLINE JSObject*
+FixUpThisIfBroken(JSObject* obj, JSObject* funobj)
+{
+    if (funobj) {
+        JSObject* parentObj =
+            &js::GetFunctionNativeReserved(funobj,
+                                           XPC_FUNCTION_PARENT_OBJECT_SLOT).toObject();
+        const js::Class* parentClass = js::GetObjectClass(parentObj);
+        if (MOZ_UNLIKELY((IS_NOHELPER_CLASS(parentClass) || IS_CU_CLASS(parentClass)) &&
+                         (js::GetObjectClass(obj) != parentClass)))
+        {
+            return parentObj;
+        }
+    }
+    return obj;
+}
+
+bool
+XPC_WN_CallMethod(JSContext* cx, unsigned argc, Value* vp)
+{
+    JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+    MOZ_ASSERT(JS_TypeOfValue(cx, args.calleev()) == JSTYPE_FUNCTION, "bad function");
+    RootedObject funobj(cx, &args.callee());
+
+    RootedObject obj(cx, JS_THIS_OBJECT(cx, vp));
+    if (!obj)
+        return false;
+
+    obj = FixUpThisIfBroken(obj, funobj);
+    XPCCallContext ccx(cx, obj, funobj, JSID_VOIDHANDLE, args.length(),
+                       args.array(), vp);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    RefPtr<XPCNativeInterface> iface;
+    XPCNativeMember*    member;
+
+    if (!XPCNativeMember::GetCallInfo(funobj, &iface, &member))
+        return Throw(NS_ERROR_XPC_CANT_GET_METHOD_INFO, cx);
+    ccx.SetCallInfo(iface, member, false);
+    return XPCWrappedNative::CallMethod(ccx);
+}
+
+bool
+XPC_WN_GetterSetter(JSContext* cx, unsigned argc, Value* vp)
+{
+    JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+    MOZ_ASSERT(JS_TypeOfValue(cx, args.calleev()) == JSTYPE_FUNCTION, "bad function");
+    RootedObject funobj(cx, &args.callee());
+
+    RootedObject obj(cx, JS_THIS_OBJECT(cx, vp));
+    if (!obj)
+        return false;
+
+    obj = FixUpThisIfBroken(obj, funobj);
+    XPCCallContext ccx(cx, obj, funobj, JSID_VOIDHANDLE, args.length(),
+                       args.array(), vp);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    RefPtr<XPCNativeInterface> iface;
+    XPCNativeMember*    member;
+
+    if (!XPCNativeMember::GetCallInfo(funobj, &iface, &member))
+        return Throw(NS_ERROR_XPC_CANT_GET_METHOD_INFO, cx);
+
+    if (args.length() != 0 && member->IsWritableAttribute()) {
+        ccx.SetCallInfo(iface, member, true);
+        bool retval = XPCWrappedNative::SetAttribute(ccx);
+        if (retval)
+            args.rval().set(args[0]);
+        return retval;
+    }
+    // else...
+
+    ccx.SetCallInfo(iface, member, false);
+    return XPCWrappedNative::GetAttribute(ccx);
+}
+
+/***************************************************************************/
+
+static bool
+XPC_WN_Shared_Proto_Enumerate(JSContext* cx, HandleObject obj)
+{
+    MOZ_ASSERT(js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_Proto_JSClass ||
+               js::GetObjectClass(obj) == &XPC_WN_NoMods_Proto_JSClass,
+               "bad proto");
+    XPCWrappedNativeProto* self =
+        (XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
+    if (!self)
+        return false;
+
+    XPCNativeSet* set = self->GetSet();
+    if (!set)
+        return false;
+
+    XPCCallContext ccx(cx);
+    if (!ccx.IsValid())
+        return false;
+
+    uint16_t interface_count = set->GetInterfaceCount();
+    XPCNativeInterface** interfaceArray = set->GetInterfaceArray();
+    for (uint16_t i = 0; i < interface_count; i++) {
+        XPCNativeInterface* iface = interfaceArray[i];
+        uint16_t member_count = iface->GetMemberCount();
+
+        for (uint16_t k = 0; k < member_count; k++) {
+            if (!xpc_ForcePropertyResolve(cx, obj, iface->GetMemberAt(k)->GetName()))
+                return false;
+        }
+    }
+
+    return true;
+}
+
+static void
+XPC_WN_Shared_Proto_Finalize(js::FreeOp* fop, JSObject* obj)
+{
+    // This can be null if xpc shutdown has already happened
+    XPCWrappedNativeProto* p = (XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
+    if (p)
+        p->JSProtoObjectFinalized(fop, obj);
+}
+
+static void
+XPC_WN_Shared_Proto_ObjectMoved(JSObject* obj, const JSObject* old)
+{
+    // This can be null if xpc shutdown has already happened
+    XPCWrappedNativeProto* p = (XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
+    if (p)
+        p->JSProtoObjectMoved(obj, old);
+}
+
+static void
+XPC_WN_Shared_Proto_Trace(JSTracer* trc, JSObject* obj)
+{
+    // This can be null if xpc shutdown has already happened
+    XPCWrappedNativeProto* p =
+        (XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
+    if (p)
+        p->TraceInside(trc);
+}
+
+/*****************************************************/
+
+static bool
+XPC_WN_ModsAllowed_Proto_Resolve(JSContext* cx, HandleObject obj, HandleId id, bool* resolvep)
+{
+    MOZ_ASSERT(js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_Proto_JSClass,
+               "bad proto");
+
+    XPCWrappedNativeProto* self =
+        (XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
+    if (!self)
+        return false;
+
+    XPCCallContext ccx(cx);
+    if (!ccx.IsValid())
+        return false;
+
+    XPCNativeScriptableInfo* si = self->GetScriptableInfo();
+    return DefinePropertyIfFound(ccx, obj, id,
+                                 self->GetSet(), nullptr, nullptr,
+                                 self->GetScope(),
+                                 true, nullptr, nullptr, si,
+                                 JSPROP_ENUMERATE, resolvep);
+}
+
+static const js::ClassOps XPC_WN_ModsAllowed_Proto_JSClassOps = {
+    nullptr,                            // addProperty
+    nullptr,                            // delProperty
+    nullptr,                            // getProperty
+    nullptr,                            // setProperty
+    XPC_WN_Shared_Proto_Enumerate,      // enumerate
+    XPC_WN_ModsAllowed_Proto_Resolve,   // resolve
+    nullptr,                            // mayResolve
+    XPC_WN_Shared_Proto_Finalize,       // finalize
+    nullptr,                            // call
+    nullptr,                            // construct
+    nullptr,                            // hasInstance
+    XPC_WN_Shared_Proto_Trace,          // trace
+};
+
+static const js::ClassExtension XPC_WN_Shared_Proto_ClassExtension = {
+    nullptr,    /* weakmapKeyDelegateOp */
+    XPC_WN_Shared_Proto_ObjectMoved
+};
+
+const js::Class XPC_WN_ModsAllowed_Proto_JSClass = {
+    "XPC_WN_ModsAllowed_Proto_JSClass",
+    XPC_WRAPPER_FLAGS,
+    &XPC_WN_ModsAllowed_Proto_JSClassOps,
+    JS_NULL_CLASS_SPEC,
+    &XPC_WN_Shared_Proto_ClassExtension,
+    JS_NULL_OBJECT_OPS
+};
+
+/***************************************************************************/
+
+static bool
+XPC_WN_OnlyIWrite_Proto_AddPropertyStub(JSContext* cx, HandleObject obj, HandleId id,
+                                        HandleValue v)
+{
+    MOZ_ASSERT(js::GetObjectClass(obj) == &XPC_WN_NoMods_Proto_JSClass,
+               "bad proto");
+
+    XPCWrappedNativeProto* self =
+        (XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
+    if (!self)
+        return false;
+
+    XPCCallContext ccx(cx);
+    if (!ccx.IsValid())
+        return false;
+
+    // Allow XPConnect to add the property only
+    if (ccx.GetResolveName() == id)
+        return true;
+
+    return Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);
+}
+
+static bool
+XPC_WN_NoMods_Proto_Resolve(JSContext* cx, HandleObject obj, HandleId id, bool* resolvedp)
+{
+    MOZ_ASSERT(js::GetObjectClass(obj) == &XPC_WN_NoMods_Proto_JSClass,
+               "bad proto");
+
+    XPCWrappedNativeProto* self =
+        (XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
+    if (!self)
+        return false;
+
+    XPCCallContext ccx(cx);
+    if (!ccx.IsValid())
+        return false;
+
+    XPCNativeScriptableInfo* si = self->GetScriptableInfo();
+
+    return DefinePropertyIfFound(ccx, obj, id,
+                                 self->GetSet(), nullptr, nullptr,
+                                 self->GetScope(),
+                                 true, nullptr, nullptr, si,
+                                 JSPROP_READONLY |
+                                 JSPROP_PERMANENT |
+                                 JSPROP_ENUMERATE, resolvedp);
+}
+
+static const js::ClassOps XPC_WN_NoMods_Proto_JSClassOps = {
+    XPC_WN_OnlyIWrite_Proto_AddPropertyStub,   // addProperty
+    XPC_WN_CantDeletePropertyStub,             // delProperty
+    nullptr,                                   // getProperty
+    nullptr,                                   // setProperty
+    XPC_WN_Shared_Proto_Enumerate,             // enumerate
+    XPC_WN_NoMods_Proto_Resolve,               // resolve
+    nullptr,                                   // mayResolve
+    XPC_WN_Shared_Proto_Finalize,              // finalize
+    nullptr,                                   // call
+    nullptr,                                   // construct
+    nullptr,                                   // hasInstance
+    XPC_WN_Shared_Proto_Trace,                 // trace
+};
+
+const js::Class XPC_WN_NoMods_Proto_JSClass = {
+    "XPC_WN_NoMods_Proto_JSClass",
+    XPC_WRAPPER_FLAGS,
+    &XPC_WN_NoMods_Proto_JSClassOps,
+    JS_NULL_CLASS_SPEC,
+    &XPC_WN_Shared_Proto_ClassExtension,
+    JS_NULL_OBJECT_OPS
+};
+
+/***************************************************************************/
+
+static bool
+XPC_WN_TearOff_Enumerate(JSContext* cx, HandleObject obj)
+{
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    XPCWrappedNativeTearOff* to = ccx.GetTearOff();
+    XPCNativeInterface* iface;
+
+    if (!to || nullptr == (iface = to->GetInterface()))
+        return Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);
+
+    uint16_t member_count = iface->GetMemberCount();
+    for (uint16_t k = 0; k < member_count; k++) {
+        if (!xpc_ForcePropertyResolve(cx, obj, iface->GetMemberAt(k)->GetName()))
+            return false;
+    }
+
+    return true;
+}
+
+static bool
+XPC_WN_TearOff_Resolve(JSContext* cx, HandleObject obj, HandleId id, bool* resolvedp)
+{
+    XPCCallContext ccx(cx, obj);
+    XPCWrappedNative* wrapper = ccx.GetWrapper();
+    THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
+
+    XPCWrappedNativeTearOff* to = ccx.GetTearOff();
+    XPCNativeInterface* iface;
+
+    if (!to || nullptr == (iface = to->GetInterface()))
+        return Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);
+
+    return DefinePropertyIfFound(ccx, obj, id, nullptr, iface, nullptr,
+                                 wrapper->GetScope(),
+                                 true, nullptr, nullptr, nullptr,
+                                 JSPROP_READONLY |
+                                 JSPROP_PERMANENT |
+                                 JSPROP_ENUMERATE, resolvedp);
+}
+
+static void
+XPC_WN_TearOff_Finalize(js::FreeOp* fop, JSObject* obj)
+{
+    XPCWrappedNativeTearOff* p = (XPCWrappedNativeTearOff*)
+        xpc_GetJSPrivate(obj);
+    if (!p)
+        return;
+    p->JSObjectFinalized();
+}
+
+static void
+XPC_WN_TearOff_ObjectMoved(JSObject* obj, const JSObject* old)
+{
+    XPCWrappedNativeTearOff* p = (XPCWrappedNativeTearOff*)
+        xpc_GetJSPrivate(obj);
+    if (!p)
+        return;
+    p->JSObjectMoved(obj, old);
+}
+
+// Make sure XPC_WRAPPER_FLAGS has no reserved slots, so our
+// XPC_WN_TEAROFF_RESERVED_SLOTS value is OK.
+
+static_assert(((XPC_WRAPPER_FLAGS >> JSCLASS_RESERVED_SLOTS_SHIFT) &
+               JSCLASS_RESERVED_SLOTS_MASK) == 0,
+              "XPC_WRAPPER_FLAGS should not include any reserved slots");
+
+static const js::ClassOps XPC_WN_Tearoff_JSClassOps = {
+    XPC_WN_OnlyIWrite_AddPropertyStub,  // addProperty
+    XPC_WN_CantDeletePropertyStub,      // delProperty
+    nullptr,                            // getProperty
+    nullptr,                            // setProperty
+    XPC_WN_TearOff_Enumerate,           // enumerate
+    XPC_WN_TearOff_Resolve,             // resolve
+    nullptr,                            // mayResolve
+    XPC_WN_TearOff_Finalize,            // finalize
+    nullptr,                            // call
+    nullptr,                            // construct
+    nullptr,                            // hasInstance
+    nullptr,                            // trace
+};
+
+static const js::ClassExtension XPC_WN_Tearoff_JSClassExtension = {
+    nullptr,                            // weakmapKeyDelegateOp
+    XPC_WN_TearOff_ObjectMoved
+};
+
+const js::Class XPC_WN_Tearoff_JSClass = {
+    "WrappedNative_TearOff",
+    XPC_WRAPPER_FLAGS |
+    JSCLASS_HAS_RESERVED_SLOTS(XPC_WN_TEAROFF_RESERVED_SLOTS),
+    &XPC_WN_Tearoff_JSClassOps,
+    JS_NULL_CLASS_SPEC,
+    &XPC_WN_Tearoff_JSClassExtension
+};
diff --git a/js/xpconnect/src/XPCWrappedNativeProto.cpp b/js/xpconnect/src/XPCWrappedNativeProto.cpp
new file mode 100644
index 000000000..d9c95a3e6
--- /dev/null
+++ b/js/xpconnect/src/XPCWrappedNativeProto.cpp
@@ -0,0 +1,208 @@
+/* -*- 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/. */
+
+/* Shared proto object for XPCWrappedNative. */
+
+#include "xpcprivate.h"
+#include "pratom.h"
+
+using namespace mozilla;
+
+#ifdef DEBUG
+int32_t XPCWrappedNativeProto::gDEBUG_LiveProtoCount = 0;
+#endif
+
+XPCWrappedNativeProto::XPCWrappedNativeProto(XPCWrappedNativeScope* Scope,
+                                             nsIClassInfo* ClassInfo,
+                                             already_AddRefed<XPCNativeSet>&& Set)
+    : mScope(Scope),
+      mJSProtoObject(nullptr),
+      mClassInfo(ClassInfo),
+      mSet(Set),
+      mScriptableInfo(nullptr)
+{
+    // This native object lives as long as its associated JSObject - killed
+    // by finalization of the JSObject (or explicitly if Init fails).
+
+    MOZ_COUNT_CTOR(XPCWrappedNativeProto);
+    MOZ_ASSERT(mScope);
+
+#ifdef DEBUG
+    gDEBUG_LiveProtoCount++;
+#endif
+}
+
+XPCWrappedNativeProto::~XPCWrappedNativeProto()
+{
+    MOZ_ASSERT(!mJSProtoObject, "JSProtoObject still alive");
+
+    MOZ_COUNT_DTOR(XPCWrappedNativeProto);
+
+#ifdef DEBUG
+    gDEBUG_LiveProtoCount--;
+#endif
+
+    // Note that our weak ref to mScope is not to be trusted at this point.
+
+    XPCNativeSet::ClearCacheEntryForClassInfo(mClassInfo);
+
+    delete mScriptableInfo;
+}
+
+bool
+XPCWrappedNativeProto::Init(const XPCNativeScriptableCreateInfo* scriptableCreateInfo,
+                            bool callPostCreatePrototype)
+{
+    AutoJSContext cx;
+    nsIXPCScriptable* callback = scriptableCreateInfo ?
+                                 scriptableCreateInfo->GetCallback() :
+                                 nullptr;
+    if (callback) {
+        mScriptableInfo =
+            XPCNativeScriptableInfo::Construct(scriptableCreateInfo);
+        if (!mScriptableInfo)
+            return false;
+    }
+
+    const js::Class* jsclazz =
+        (mScriptableInfo &&
+         mScriptableInfo->GetFlags().AllowPropModsToPrototype())
+        ? &XPC_WN_ModsAllowed_Proto_JSClass
+        : &XPC_WN_NoMods_Proto_JSClass;
+
+    JS::RootedObject global(cx, mScope->GetGlobalJSObject());
+    JS::RootedObject proto(cx, JS_GetObjectPrototype(cx, global));
+    mJSProtoObject = JS_NewObjectWithUniqueType(cx, js::Jsvalify(jsclazz),
+                                                proto);
+
+    bool success = !!mJSProtoObject;
+    if (success) {
+        JS_SetPrivate(mJSProtoObject, this);
+        if (callPostCreatePrototype)
+            success = CallPostCreatePrototype();
+    }
+
+    return success;
+}
+
+bool
+XPCWrappedNativeProto::CallPostCreatePrototype()
+{
+    AutoJSContext cx;
+
+    // Nothing to do if we don't have a scriptable callback.
+    nsIXPCScriptable* callback = mScriptableInfo ? mScriptableInfo->GetCallback()
+                                                 : nullptr;
+    if (!callback)
+        return true;
+
+    // Call the helper. This can handle being called if it's not implemented,
+    // so we don't have to check any sort of "want" here. See xpc_map_end.h.
+    nsresult rv = callback->PostCreatePrototype(cx, mJSProtoObject);
+    if (NS_FAILED(rv)) {
+        JS_SetPrivate(mJSProtoObject, nullptr);
+        mJSProtoObject = nullptr;
+        XPCThrower::Throw(rv, cx);
+        return false;
+    }
+
+    return true;
+}
+
+void
+XPCWrappedNativeProto::JSProtoObjectFinalized(js::FreeOp* fop, JSObject* obj)
+{
+    MOZ_ASSERT(obj == mJSProtoObject.unbarrieredGet(), "huh?");
+
+    // Only remove this proto from the map if it is the one in the map.
+    ClassInfo2WrappedNativeProtoMap* map = GetScope()->GetWrappedNativeProtoMap();
+    if (map->Find(mClassInfo) == this)
+        map->Remove(mClassInfo);
+
+    GetContext()->GetDyingWrappedNativeProtoMap()->Add(this);
+
+    mJSProtoObject.finalize(js::CastToJSFreeOp(fop)->runtime());
+}
+
+void
+XPCWrappedNativeProto::JSProtoObjectMoved(JSObject* obj, const JSObject* old)
+{
+    MOZ_ASSERT(mJSProtoObject.unbarrieredGet() == old);
+    mJSProtoObject.init(obj); // Update without triggering barriers.
+}
+
+void
+XPCWrappedNativeProto::SystemIsBeingShutDown()
+{
+    // Note that the instance might receive this call multiple times
+    // as we walk to here from various places.
+
+    if (mJSProtoObject) {
+        // short circuit future finalization
+        JS_SetPrivate(mJSProtoObject, nullptr);
+        mJSProtoObject = nullptr;
+    }
+}
+
+// static
+XPCWrappedNativeProto*
+XPCWrappedNativeProto::GetNewOrUsed(XPCWrappedNativeScope* scope,
+                                    nsIClassInfo* classInfo,
+                                    const XPCNativeScriptableCreateInfo* scriptableCreateInfo,
+                                    bool callPostCreatePrototype)
+{
+    AutoJSContext cx;
+    MOZ_ASSERT(scope, "bad param");
+    MOZ_ASSERT(classInfo, "bad param");
+
+    AutoMarkingWrappedNativeProtoPtr proto(cx);
+    ClassInfo2WrappedNativeProtoMap* map = nullptr;
+
+    map = scope->GetWrappedNativeProtoMap();
+    proto = map->Find(classInfo);
+    if (proto)
+        return proto;
+
+    RefPtr<XPCNativeSet> set = XPCNativeSet::GetNewOrUsed(classInfo);
+    if (!set)
+        return nullptr;
+
+    proto = new XPCWrappedNativeProto(scope, classInfo, set.forget());
+
+    if (!proto || !proto->Init(scriptableCreateInfo, callPostCreatePrototype)) {
+        delete proto.get();
+        return nullptr;
+    }
+
+    map->Add(classInfo, proto);
+
+    return proto;
+}
+
+void
+XPCWrappedNativeProto::DebugDump(int16_t depth)
+{
+#ifdef DEBUG
+    depth-- ;
+    XPC_LOG_ALWAYS(("XPCWrappedNativeProto @ %x", this));
+    XPC_LOG_INDENT();
+        XPC_LOG_ALWAYS(("gDEBUG_LiveProtoCount is %d", gDEBUG_LiveProtoCount));
+        XPC_LOG_ALWAYS(("mScope @ %x", mScope));
+        XPC_LOG_ALWAYS(("mJSProtoObject @ %x", mJSProtoObject.get()));
+        XPC_LOG_ALWAYS(("mSet @ %x", mSet.get()));
+        XPC_LOG_ALWAYS(("mScriptableInfo @ %x", mScriptableInfo));
+        if (depth && mScriptableInfo) {
+            XPC_LOG_INDENT();
+            XPC_LOG_ALWAYS(("mScriptable @ %x", mScriptableInfo->GetCallback()));
+            XPC_LOG_ALWAYS(("mFlags of %x", (uint32_t)mScriptableInfo->GetFlags()));
+            XPC_LOG_ALWAYS(("mJSClass @ %x", mScriptableInfo->GetJSClass()));
+            XPC_LOG_OUTDENT();
+        }
+    XPC_LOG_OUTDENT();
+#endif
+}
+
+
diff --git a/js/xpconnect/src/XPCWrappedNativeScope.cpp b/js/xpconnect/src/XPCWrappedNativeScope.cpp
new file mode 100644
index 000000000..24f1067d0
--- /dev/null
+++ b/js/xpconnect/src/XPCWrappedNativeScope.cpp
@@ -0,0 +1,934 @@
+/* -*- 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/. */
+
+/* Class used to manage the wrapped native objects within a JS scope. */
+
+#include "xpcprivate.h"
+#include "XPCWrapper.h"
+#include "nsContentUtils.h"
+#include "nsCycleCollectionNoteRootCallback.h"
+#include "nsPrincipal.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Preferences.h"
+#include "nsIAddonInterposition.h"
+#include "nsIXULRuntime.h"
+
+#include "mozilla/dom/BindingUtils.h"
+
+using namespace mozilla;
+using namespace xpc;
+using namespace JS;
+
+/***************************************************************************/
+
+XPCWrappedNativeScope* XPCWrappedNativeScope::gScopes = nullptr;
+XPCWrappedNativeScope* XPCWrappedNativeScope::gDyingScopes = nullptr;
+bool XPCWrappedNativeScope::gShutdownObserverInitialized = false;
+XPCWrappedNativeScope::InterpositionMap* XPCWrappedNativeScope::gInterpositionMap = nullptr;
+InterpositionWhitelistArray* XPCWrappedNativeScope::gInterpositionWhitelists = nullptr;
+XPCWrappedNativeScope::AddonSet* XPCWrappedNativeScope::gAllowCPOWAddonSet = nullptr;
+
+NS_IMPL_ISUPPORTS(XPCWrappedNativeScope::ClearInterpositionsObserver, nsIObserver)
+
+NS_IMETHODIMP
+XPCWrappedNativeScope::ClearInterpositionsObserver::Observe(nsISupports* subject,
+                                                            const char* topic,
+                                                            const char16_t* data)
+{
+    MOZ_ASSERT(strcmp(topic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0);
+
+    // The interposition map holds strong references to interpositions, which
+    // may themselves be involved in cycles. We need to drop these strong
+    // references before the cycle collector shuts down. Otherwise we'll
+    // leak. This observer always runs before CC shutdown.
+    if (gInterpositionMap) {
+        delete gInterpositionMap;
+        gInterpositionMap = nullptr;
+    }
+
+    if (gInterpositionWhitelists) {
+        delete gInterpositionWhitelists;
+        gInterpositionWhitelists = nullptr;
+    }
+
+    if (gAllowCPOWAddonSet) {
+        delete gAllowCPOWAddonSet;
+        gAllowCPOWAddonSet = nullptr;
+    }
+
+    nsContentUtils::UnregisterShutdownObserver(this);
+    return NS_OK;
+}
+
+static bool
+RemoteXULForbidsXBLScope(nsIPrincipal* aPrincipal, HandleObject aGlobal)
+{
+  MOZ_ASSERT(aPrincipal);
+
+  // Certain singleton sandoxes are created very early in startup - too early
+  // to call into AllowXULXBLForPrincipal. We never create XBL scopes for
+  // sandboxes anway, and certainly not for these singleton scopes. So we just
+  // short-circuit here.
+  if (IsSandbox(aGlobal))
+      return false;
+
+  // AllowXULXBLForPrincipal will return true for system principal, but we
+  // don't want that here.
+  MOZ_ASSERT(nsContentUtils::IsInitialized());
+  if (nsContentUtils::IsSystemPrincipal(aPrincipal))
+      return false;
+
+  // If this domain isn't whitelisted, we're done.
+  if (!nsContentUtils::AllowXULXBLForPrincipal(aPrincipal))
+      return false;
+
+  // Check the pref to determine how we should behave.
+  return !Preferences::GetBool("dom.use_xbl_scopes_for_remote_xul", false);
+}
+
+XPCWrappedNativeScope::XPCWrappedNativeScope(JSContext* cx,
+                                             JS::HandleObject aGlobal)
+      : mWrappedNativeMap(Native2WrappedNativeMap::newMap(XPC_NATIVE_MAP_LENGTH)),
+        mWrappedNativeProtoMap(ClassInfo2WrappedNativeProtoMap::newMap(XPC_NATIVE_PROTO_MAP_LENGTH)),
+        mComponents(nullptr),
+        mNext(nullptr),
+        mGlobalJSObject(aGlobal),
+        mHasCallInterpositions(false),
+        mIsContentXBLScope(false),
+        mIsAddonScope(false)
+{
+    // add ourselves to the scopes list
+    {
+        MOZ_ASSERT(aGlobal);
+        DebugOnly<const js::Class*> clasp = js::GetObjectClass(aGlobal);
+        MOZ_ASSERT(clasp->flags & (JSCLASS_PRIVATE_IS_NSISUPPORTS |
+                                   JSCLASS_HAS_PRIVATE) ||
+                   mozilla::dom::IsDOMClass(clasp));
+#ifdef DEBUG
+        for (XPCWrappedNativeScope* cur = gScopes; cur; cur = cur->mNext)
+            MOZ_ASSERT(aGlobal != cur->GetGlobalJSObjectPreserveColor(), "dup object");
+#endif
+
+        mNext = gScopes;
+        gScopes = this;
+    }
+
+    MOZ_COUNT_CTOR(XPCWrappedNativeScope);
+
+    // Create the compartment private.
+    JSCompartment* c = js::GetObjectCompartment(aGlobal);
+    MOZ_ASSERT(!JS_GetCompartmentPrivate(c));
+    CompartmentPrivate* priv = new CompartmentPrivate(c);
+    JS_SetCompartmentPrivate(c, priv);
+
+    // Attach ourselves to the compartment private.
+    priv->scope = this;
+
+    // Determine whether we would allow an XBL scope in this situation.
+    // In addition to being pref-controlled, we also disable XBL scopes for
+    // remote XUL domains, _except_ if we have an additional pref override set.
+    nsIPrincipal* principal = GetPrincipal();
+    mAllowContentXBLScope = !RemoteXULForbidsXBLScope(principal, aGlobal);
+
+    // Determine whether to use an XBL scope.
+    mUseContentXBLScope = mAllowContentXBLScope;
+    if (mUseContentXBLScope) {
+      const js::Class* clasp = js::GetObjectClass(mGlobalJSObject);
+      mUseContentXBLScope = !strcmp(clasp->name, "Window");
+    }
+    if (mUseContentXBLScope) {
+      mUseContentXBLScope = principal && !nsContentUtils::IsSystemPrincipal(principal);
+    }
+
+    JSAddonId* addonId = JS::AddonIdOfObject(aGlobal);
+    if (gInterpositionMap) {
+        bool isSystem = nsContentUtils::IsSystemPrincipal(principal);
+        bool waiveInterposition = priv->waiveInterposition;
+        InterpositionMap::Ptr interposition = gInterpositionMap->lookup(addonId);
+        if (!waiveInterposition && interposition) {
+            MOZ_RELEASE_ASSERT(isSystem);
+            mInterposition = interposition->value();
+        }
+        // We also want multiprocessCompatible add-ons to have a default interposition.
+        if (!mInterposition && addonId && isSystem) {
+          bool interpositionEnabled = mozilla::Preferences::GetBool(
+            "extensions.interposition.enabled", false);
+          if (interpositionEnabled) {
+            mInterposition = do_GetService("@mozilla.org/addons/default-addon-shims;1");
+            MOZ_ASSERT(mInterposition);
+            UpdateInterpositionWhitelist(cx, mInterposition);
+          }
+        }
+    }
+
+    if (addonId) {
+        // We forbid CPOWs unless they're specifically allowed.
+        priv->allowCPOWs = gAllowCPOWAddonSet ? gAllowCPOWAddonSet->has(addonId) : false;
+    }
+}
+
+// static
+bool
+XPCWrappedNativeScope::IsDyingScope(XPCWrappedNativeScope* scope)
+{
+    for (XPCWrappedNativeScope* cur = gDyingScopes; cur; cur = cur->mNext) {
+        if (scope == cur)
+            return true;
+    }
+    return false;
+}
+
+bool
+XPCWrappedNativeScope::GetComponentsJSObject(JS::MutableHandleObject obj)
+{
+    AutoJSContext cx;
+    if (!mComponents) {
+        nsIPrincipal* p = GetPrincipal();
+        bool system = nsXPConnect::SecurityManager()->IsSystemPrincipal(p);
+        mComponents = system ? new nsXPCComponents(this)
+                             : new nsXPCComponentsBase(this);
+    }
+
+    RootedValue val(cx);
+    xpcObjectHelper helper(mComponents);
+    bool ok = XPCConvert::NativeInterface2JSObject(&val, nullptr, helper,
+                                                   nullptr, false,
+                                                   nullptr);
+    if (NS_WARN_IF(!ok))
+        return false;
+
+    if (NS_WARN_IF(!val.isObject()))
+        return false;
+
+    // The call to wrap() here is necessary even though the object is same-
+    // compartment, because it applies our security wrapper.
+    obj.set(&val.toObject());
+    if (NS_WARN_IF(!JS_WrapObject(cx, obj)))
+        return false;
+    return true;
+}
+
+void
+XPCWrappedNativeScope::ForcePrivilegedComponents()
+{
+    nsCOMPtr<nsIXPCComponents> c = do_QueryInterface(mComponents);
+    if (!c)
+        mComponents = new nsXPCComponents(this);
+}
+
+bool
+XPCWrappedNativeScope::AttachComponentsObject(JSContext* aCx)
+{
+    RootedObject components(aCx);
+    if (!GetComponentsJSObject(&components))
+        return false;
+
+    RootedObject global(aCx, GetGlobalJSObject());
+    MOZ_ASSERT(js::IsObjectInContextCompartment(global, aCx));
+
+    // The global Components property is non-configurable if it's a full
+    // nsXPCComponents object. That way, if it's an nsXPCComponentsBase,
+    // enableUniversalXPConnect can upgrade it later.
+    unsigned attrs = JSPROP_READONLY | JSPROP_RESOLVING;
+    nsCOMPtr<nsIXPCComponents> c = do_QueryInterface(mComponents);
+    if (c)
+        attrs |= JSPROP_PERMANENT;
+
+    RootedId id(aCx, XPCJSContext::Get()->GetStringID(XPCJSContext::IDX_COMPONENTS));
+    return JS_DefinePropertyById(aCx, global, id, components, attrs);
+}
+
+static bool
+CompartmentPerAddon()
+{
+    static bool initialized = false;
+    static bool pref = false;
+
+    if (!initialized) {
+        pref = Preferences::GetBool("dom.compartment_per_addon", false) ||
+               BrowserTabsRemoteAutostart();
+        initialized = true;
+    }
+
+    return pref;
+}
+
+JSObject*
+XPCWrappedNativeScope::EnsureContentXBLScope(JSContext* cx)
+{
+    JS::RootedObject global(cx, GetGlobalJSObject());
+    MOZ_ASSERT(js::IsObjectInContextCompartment(global, cx));
+    MOZ_ASSERT(!mIsContentXBLScope);
+    MOZ_ASSERT(strcmp(js::GetObjectClass(global)->name,
+                      "nsXBLPrototypeScript compilation scope"));
+
+    // If we already have a special XBL scope object, we know what to use.
+    if (mContentXBLScope)
+        return mContentXBLScope;
+
+    // If this scope doesn't need an XBL scope, just return the global.
+    if (!mUseContentXBLScope)
+        return global;
+
+    // Set up the sandbox options. Note that we use the DOM global as the
+    // sandboxPrototype so that the XBL scope can access all the DOM objects
+    // it's accustomed to accessing.
+    //
+    // In general wantXrays shouldn't matter much here, but there are weird
+    // cases when adopting bound content between same-origin globals where a
+    // <destructor> in one content XBL scope sees anonymous content in another
+    // content XBL scope. When that happens, we hit LookupBindingMember for an
+    // anonymous element that lives in a content XBL scope, which isn't a tested
+    // or audited codepath. So let's avoid hitting that case by opting out of
+    // same-origin Xrays.
+    SandboxOptions options;
+    options.wantXrays = false;
+    options.wantComponents = true;
+    options.proto = global;
+    options.sameZoneAs = global;
+
+    // Use an nsExpandedPrincipal to create asymmetric security.
+    nsIPrincipal* principal = GetPrincipal();
+    MOZ_ASSERT(!nsContentUtils::IsExpandedPrincipal(principal));
+    nsTArray<nsCOMPtr<nsIPrincipal>> principalAsArray(1);
+    principalAsArray.AppendElement(principal);
+    nsCOMPtr<nsIExpandedPrincipal> ep =
+        new nsExpandedPrincipal(principalAsArray,
+                                BasePrincipal::Cast(principal)->OriginAttributesRef());
+
+    // Create the sandbox.
+    RootedValue v(cx);
+    nsresult rv = CreateSandboxObject(cx, &v, ep, options);
+    NS_ENSURE_SUCCESS(rv, nullptr);
+    mContentXBLScope = &v.toObject();
+
+    // Tag it.
+    CompartmentPrivate::Get(js::UncheckedUnwrap(mContentXBLScope))->scope->mIsContentXBLScope = true;
+
+    // Good to go!
+    return mContentXBLScope;
+}
+
+bool
+XPCWrappedNativeScope::AllowContentXBLScope()
+{
+    // We only disallow XBL scopes in remote XUL situations.
+    MOZ_ASSERT_IF(!mAllowContentXBLScope,
+                  nsContentUtils::AllowXULXBLForPrincipal(GetPrincipal()));
+    return mAllowContentXBLScope;
+}
+
+namespace xpc {
+JSObject*
+GetXBLScope(JSContext* cx, JSObject* contentScopeArg)
+{
+    MOZ_ASSERT(!IsInAddonScope(contentScopeArg));
+
+    JS::RootedObject contentScope(cx, contentScopeArg);
+    JSAutoCompartment ac(cx, contentScope);
+    JSObject* scope = CompartmentPrivate::Get(contentScope)->scope->EnsureContentXBLScope(cx);
+    NS_ENSURE_TRUE(scope, nullptr); // See bug 858642.
+    scope = js::UncheckedUnwrap(scope);
+    JS::ExposeObjectToActiveJS(scope);
+    return scope;
+}
+
+JSObject*
+GetScopeForXBLExecution(JSContext* cx, HandleObject contentScope, JSAddonId* addonId)
+{
+    MOZ_RELEASE_ASSERT(!IsInAddonScope(contentScope));
+
+    RootedObject global(cx, js::GetGlobalForObjectCrossCompartment(contentScope));
+    if (IsInContentXBLScope(contentScope))
+        return global;
+
+    JSAutoCompartment ac(cx, contentScope);
+    XPCWrappedNativeScope* nativeScope = CompartmentPrivate::Get(contentScope)->scope;
+    bool isSystem = nsContentUtils::IsSystemPrincipal(nativeScope->GetPrincipal());
+
+    RootedObject scope(cx);
+    if (nativeScope->UseContentXBLScope())
+        scope = nativeScope->EnsureContentXBLScope(cx);
+    else if (addonId && CompartmentPerAddon() && isSystem)
+        scope = nativeScope->EnsureAddonScope(cx, addonId);
+    else
+        scope = global;
+
+    NS_ENSURE_TRUE(scope, nullptr); // See bug 858642.
+    scope = js::UncheckedUnwrap(scope);
+    JS::ExposeObjectToActiveJS(scope);
+    return scope;
+}
+
+bool
+AllowContentXBLScope(JSCompartment* c)
+{
+  XPCWrappedNativeScope* scope = CompartmentPrivate::Get(c)->scope;
+  return scope && scope->AllowContentXBLScope();
+}
+
+bool
+UseContentXBLScope(JSCompartment* c)
+{
+  XPCWrappedNativeScope* scope = CompartmentPrivate::Get(c)->scope;
+  return scope && scope->UseContentXBLScope();
+}
+
+void
+ClearContentXBLScope(JSObject* global)
+{
+    CompartmentPrivate::Get(global)->scope->ClearContentXBLScope();
+}
+
+} /* namespace xpc */
+
+JSObject*
+XPCWrappedNativeScope::EnsureAddonScope(JSContext* cx, JSAddonId* addonId)
+{
+    JS::RootedObject global(cx, GetGlobalJSObject());
+    MOZ_ASSERT(js::IsObjectInContextCompartment(global, cx));
+    MOZ_ASSERT(!mIsContentXBLScope);
+    MOZ_ASSERT(!mIsAddonScope);
+    MOZ_ASSERT(addonId);
+    MOZ_ASSERT(nsContentUtils::IsSystemPrincipal(GetPrincipal()));
+
+    // In bug 1092156, we found that add-on scopes don't work correctly when the
+    // window navigates. The add-on global's prototype is an outer window, so,
+    // after the navigation, looking up window properties in the add-on scope
+    // will fail. However, in most cases where the window can be navigated, the
+    // entire window is part of the add-on. To solve the problem, we avoid
+    // returning an add-on scope for a window that is already tagged with the
+    // add-on ID.
+    if (AddonIdOfObject(global) == addonId)
+        return global;
+
+    // If we already have an addon scope object, we know what to use.
+    for (size_t i = 0; i < mAddonScopes.Length(); i++) {
+        if (JS::AddonIdOfObject(js::UncheckedUnwrap(mAddonScopes[i])) == addonId)
+            return mAddonScopes[i];
+    }
+
+    SandboxOptions options;
+    options.wantComponents = true;
+    options.proto = global;
+    options.sameZoneAs = global;
+    options.addonId = JS::StringOfAddonId(addonId);
+    options.writeToGlobalPrototype = true;
+
+    RootedValue v(cx);
+    nsresult rv = CreateSandboxObject(cx, &v, GetPrincipal(), options);
+    NS_ENSURE_SUCCESS(rv, nullptr);
+    mAddonScopes.AppendElement(&v.toObject());
+
+    CompartmentPrivate::Get(js::UncheckedUnwrap(&v.toObject()))->scope->mIsAddonScope = true;
+    return &v.toObject();
+}
+
+JSObject*
+xpc::GetAddonScope(JSContext* cx, JS::HandleObject contentScope, JSAddonId* addonId)
+{
+    MOZ_RELEASE_ASSERT(!IsInAddonScope(contentScope));
+
+    if (!addonId || !CompartmentPerAddon()) {
+        return js::GetGlobalForObjectCrossCompartment(contentScope);
+    }
+
+    JSAutoCompartment ac(cx, contentScope);
+    XPCWrappedNativeScope* nativeScope = CompartmentPrivate::Get(contentScope)->scope;
+    if (nativeScope->GetPrincipal() != nsXPConnect::SystemPrincipal()) {
+        // This can happen if, for example, Jetpack loads an unprivileged HTML
+        // page from the add-on. It's not clear what to do there, so we just use
+        // the normal global.
+        return js::GetGlobalForObjectCrossCompartment(contentScope);
+    }
+    JSObject* scope = nativeScope->EnsureAddonScope(cx, addonId);
+    NS_ENSURE_TRUE(scope, nullptr);
+
+    scope = js::UncheckedUnwrap(scope);
+    JS::ExposeObjectToActiveJS(scope);
+    return scope;
+}
+
+XPCWrappedNativeScope::~XPCWrappedNativeScope()
+{
+    MOZ_COUNT_DTOR(XPCWrappedNativeScope);
+
+    // We can do additional cleanup assertions here...
+
+    MOZ_ASSERT(0 == mWrappedNativeMap->Count(), "scope has non-empty map");
+    delete mWrappedNativeMap;
+
+    MOZ_ASSERT(0 == mWrappedNativeProtoMap->Count(), "scope has non-empty map");
+    delete mWrappedNativeProtoMap;
+
+    // This should not be necessary, since the Components object should die
+    // with the scope but just in case.
+    if (mComponents)
+        mComponents->mScope = nullptr;
+
+    // XXX we should assert that we are dead or that xpconnect has shutdown
+    // XXX might not want to do this at xpconnect shutdown time???
+    mComponents = nullptr;
+
+    if (mXrayExpandos.initialized())
+        mXrayExpandos.destroy();
+
+    JSContext* cx = dom::danger::GetJSContext();
+    mContentXBLScope.finalize(cx);
+    for (size_t i = 0; i < mAddonScopes.Length(); i++)
+        mAddonScopes[i].finalize(cx);
+    mGlobalJSObject.finalize(cx);
+}
+
+// static
+void
+XPCWrappedNativeScope::TraceWrappedNativesInAllScopes(JSTracer* trc, XPCJSContext* cx)
+{
+    // Do JS::TraceEdge for all wrapped natives with external references, as
+    // well as any DOM expando objects.
+    for (XPCWrappedNativeScope* cur = gScopes; cur; cur = cur->mNext) {
+        for (auto i = cur->mWrappedNativeMap->Iter(); !i.Done(); i.Next()) {
+            auto entry = static_cast<Native2WrappedNativeMap::Entry*>(i.Get());
+            XPCWrappedNative* wrapper = entry->value;
+            if (wrapper->HasExternalReference() && !wrapper->IsWrapperExpired())
+                wrapper->TraceSelf(trc);
+        }
+
+        if (cur->mDOMExpandoSet) {
+            for (DOMExpandoSet::Enum e(*cur->mDOMExpandoSet); !e.empty(); e.popFront())
+                JS::TraceEdge(trc, &e.mutableFront(), "DOM expando object");
+        }
+    }
+}
+
+static void
+SuspectDOMExpandos(JSObject* obj, nsCycleCollectionNoteRootCallback& cb)
+{
+    MOZ_ASSERT(dom::GetDOMClass(obj) && dom::GetDOMClass(obj)->mDOMObjectIsISupports);
+    nsISupports* native = dom::UnwrapDOMObject<nsISupports>(obj);
+    cb.NoteXPCOMRoot(native);
+}
+
+// static
+void
+XPCWrappedNativeScope::SuspectAllWrappers(XPCJSContext* cx,
+                                          nsCycleCollectionNoteRootCallback& cb)
+{
+    for (XPCWrappedNativeScope* cur = gScopes; cur; cur = cur->mNext) {
+        for (auto i = cur->mWrappedNativeMap->Iter(); !i.Done(); i.Next()) {
+            static_cast<Native2WrappedNativeMap::Entry*>(i.Get())->value->Suspect(cb);
+        }
+
+        if (cur->mDOMExpandoSet) {
+            for (DOMExpandoSet::Range r = cur->mDOMExpandoSet->all(); !r.empty(); r.popFront())
+                SuspectDOMExpandos(r.front().unbarrieredGet(), cb);
+        }
+    }
+}
+
+// static
+void
+XPCWrappedNativeScope::UpdateWeakPointersAfterGC(XPCJSContext* cx)
+{
+    // If this is called from the finalization callback in JSGC_MARK_END then
+    // JSGC_FINALIZE_END must always follow it calling
+    // FinishedFinalizationPhaseOfGC and clearing gDyingScopes in
+    // KillDyingScopes.
+    MOZ_ASSERT(!gDyingScopes, "JSGC_MARK_END without JSGC_FINALIZE_END");
+
+    XPCWrappedNativeScope* prev = nullptr;
+    XPCWrappedNativeScope* cur = gScopes;
+
+    while (cur) {
+        // Sweep waivers.
+        if (cur->mWaiverWrapperMap)
+            cur->mWaiverWrapperMap->Sweep();
+
+        XPCWrappedNativeScope* next = cur->mNext;
+
+        if (cur->mContentXBLScope)
+            cur->mContentXBLScope.updateWeakPointerAfterGC();
+        for (size_t i = 0; i < cur->mAddonScopes.Length(); i++)
+            cur->mAddonScopes[i].updateWeakPointerAfterGC();
+
+        // Check for finalization of the global object or update our pointer if
+        // it was moved.
+        if (cur->mGlobalJSObject) {
+            cur->mGlobalJSObject.updateWeakPointerAfterGC();
+            if (!cur->mGlobalJSObject) {
+                // Move this scope from the live list to the dying list.
+                if (prev)
+                    prev->mNext = next;
+                else
+                    gScopes = next;
+                cur->mNext = gDyingScopes;
+                gDyingScopes = cur;
+                cur = nullptr;
+            }
+        }
+
+        if (cur)
+            prev = cur;
+        cur = next;
+    }
+}
+
+// static
+void
+XPCWrappedNativeScope::SweepAllWrappedNativeTearOffs()
+{
+    for (XPCWrappedNativeScope* cur = gScopes; cur; cur = cur->mNext) {
+        for (auto i = cur->mWrappedNativeMap->Iter(); !i.Done(); i.Next()) {
+            auto entry = static_cast<Native2WrappedNativeMap::Entry*>(i.Get());
+            entry->value->SweepTearOffs();
+        }
+    }
+}
+
+// static
+void
+XPCWrappedNativeScope::KillDyingScopes()
+{
+    XPCWrappedNativeScope* cur = gDyingScopes;
+    while (cur) {
+        XPCWrappedNativeScope* next = cur->mNext;
+        if (cur->mGlobalJSObject)
+            CompartmentPrivate::Get(cur->mGlobalJSObject)->scope = nullptr;
+        delete cur;
+        cur = next;
+    }
+    gDyingScopes = nullptr;
+}
+
+//static
+void
+XPCWrappedNativeScope::SystemIsBeingShutDown()
+{
+    int liveScopeCount = 0;
+
+    XPCWrappedNativeScope* cur;
+
+    // First move all the scopes to the dying list.
+
+    cur = gScopes;
+    while (cur) {
+        XPCWrappedNativeScope* next = cur->mNext;
+        cur->mNext = gDyingScopes;
+        gDyingScopes = cur;
+        cur = next;
+        liveScopeCount++;
+    }
+    gScopes = nullptr;
+
+    // We're forcibly killing scopes, rather than allowing them to go away
+    // when they're ready. As such, we need to do some cleanup before they
+    // can safely be destroyed.
+
+    for (cur = gDyingScopes; cur; cur = cur->mNext) {
+        // Give the Components object a chance to try to clean up.
+        if (cur->mComponents)
+            cur->mComponents->SystemIsBeingShutDown();
+
+        // Walk the protos first. Wrapper shutdown can leave dangling
+        // proto pointers in the proto map.
+        for (auto i = cur->mWrappedNativeProtoMap->Iter(); !i.Done(); i.Next()) {
+            auto entry = static_cast<ClassInfo2WrappedNativeProtoMap::Entry*>(i.Get());
+            entry->value->SystemIsBeingShutDown();
+            i.Remove();
+        }
+        for (auto i = cur->mWrappedNativeMap->Iter(); !i.Done(); i.Next()) {
+            auto entry = static_cast<Native2WrappedNativeMap::Entry*>(i.Get());
+            XPCWrappedNative* wrapper = entry->value;
+            if (wrapper->IsValid()) {
+                wrapper->SystemIsBeingShutDown();
+            }
+            i.Remove();
+        }
+    }
+
+    // Now it is safe to kill all the scopes.
+    KillDyingScopes();
+}
+
+
+/***************************************************************************/
+
+JSObject*
+XPCWrappedNativeScope::GetExpandoChain(HandleObject target)
+{
+    MOZ_ASSERT(ObjectScope(target) == this);
+    if (!mXrayExpandos.initialized())
+        return nullptr;
+    return mXrayExpandos.lookup(target);
+}
+
+bool
+XPCWrappedNativeScope::SetExpandoChain(JSContext* cx, HandleObject target,
+                                       HandleObject chain)
+{
+    MOZ_ASSERT(ObjectScope(target) == this);
+    MOZ_ASSERT(js::IsObjectInContextCompartment(target, cx));
+    MOZ_ASSERT_IF(chain, ObjectScope(chain) == this);
+    if (!mXrayExpandos.initialized() && !mXrayExpandos.init(cx))
+        return false;
+    return mXrayExpandos.put(cx, target, chain);
+}
+
+/* static */ bool
+XPCWrappedNativeScope::SetAddonInterposition(JSContext* cx,
+                                             JSAddonId* addonId,
+                                             nsIAddonInterposition* interp)
+{
+    if (!gInterpositionMap) {
+        gInterpositionMap = new InterpositionMap();
+        bool ok = gInterpositionMap->init();
+        NS_ENSURE_TRUE(ok, false);
+
+        if (!gShutdownObserverInitialized) {
+            gShutdownObserverInitialized = true;
+            nsContentUtils::RegisterShutdownObserver(new ClearInterpositionsObserver());
+        }
+    }
+    if (interp) {
+        bool ok = gInterpositionMap->put(addonId, interp);
+        NS_ENSURE_TRUE(ok, false);
+        UpdateInterpositionWhitelist(cx, interp);
+    } else {
+        gInterpositionMap->remove(addonId);
+    }
+    return true;
+}
+
+/* static */ bool
+XPCWrappedNativeScope::AllowCPOWsInAddon(JSContext* cx,
+                                         JSAddonId* addonId,
+                                         bool allow)
+{
+    if (!gAllowCPOWAddonSet) {
+        gAllowCPOWAddonSet = new AddonSet();
+        bool ok = gAllowCPOWAddonSet->init();
+        NS_ENSURE_TRUE(ok, false);
+
+        if (!gShutdownObserverInitialized) {
+            gShutdownObserverInitialized = true;
+            nsContentUtils::RegisterShutdownObserver(new ClearInterpositionsObserver());
+        }
+    }
+    if (allow) {
+        bool ok = gAllowCPOWAddonSet->put(addonId);
+        NS_ENSURE_TRUE(ok, false);
+    } else {
+        gAllowCPOWAddonSet->remove(addonId);
+    }
+    return true;
+}
+
+nsCOMPtr<nsIAddonInterposition>
+XPCWrappedNativeScope::GetInterposition()
+{
+    return mInterposition;
+}
+
+/* static */ InterpositionWhitelist*
+XPCWrappedNativeScope::GetInterpositionWhitelist(nsIAddonInterposition* interposition)
+{
+    if (!gInterpositionWhitelists)
+        return nullptr;
+
+    InterpositionWhitelistArray& wls = *gInterpositionWhitelists;
+    for (size_t i = 0; i < wls.Length(); i++) {
+        if (wls[i].interposition == interposition)
+            return &wls[i].whitelist;
+    }
+
+    return nullptr;
+}
+
+/* static */ bool
+XPCWrappedNativeScope::UpdateInterpositionWhitelist(JSContext* cx,
+                                                    nsIAddonInterposition* interposition)
+{
+    // We want to set the interpostion whitelist only once.
+    InterpositionWhitelist* whitelist = GetInterpositionWhitelist(interposition);
+    if (whitelist)
+        return true;
+
+    // The hashsets in gInterpositionWhitelists do not have a copy constructor so
+    // a reallocation for the array will lead to a memory corruption. If you
+    // need more interpositions, change the capacity of the array please.
+    static const size_t MAX_INTERPOSITION = 8;
+    if (!gInterpositionWhitelists)
+        gInterpositionWhitelists = new InterpositionWhitelistArray(MAX_INTERPOSITION);
+
+    MOZ_RELEASE_ASSERT(MAX_INTERPOSITION > gInterpositionWhitelists->Length() + 1);
+    InterpositionWhitelistPair* newPair = gInterpositionWhitelists->AppendElement();
+    newPair->interposition = interposition;
+    if (!newPair->whitelist.init()) {
+        JS_ReportOutOfMemory(cx);
+        return false;
+    }
+
+    whitelist = &newPair->whitelist;
+
+    RootedValue whitelistVal(cx);
+    nsresult rv = interposition->GetWhitelist(&whitelistVal);
+    if (NS_FAILED(rv)) {
+        JS_ReportErrorASCII(cx, "Could not get the whitelist from the interposition.");
+        return false;
+    }
+
+    if (!whitelistVal.isObject()) {
+        JS_ReportErrorASCII(cx, "Whitelist must be an array.");
+        return false;
+    }
+
+    // We want to enter the whitelist's compartment to avoid any wrappers.
+    // To be on the safe side let's make sure that it's a system compartment
+    // and we don't accidentally trigger some content function here by parsing
+    // the whitelist object.
+    RootedObject whitelistObj(cx, &whitelistVal.toObject());
+    whitelistObj = js::UncheckedUnwrap(whitelistObj);
+    if (!AccessCheck::isChrome(whitelistObj)) {
+        JS_ReportErrorASCII(cx, "Whitelist must be from system scope.");
+        return false;
+    }
+
+    {
+        JSAutoCompartment ac(cx, whitelistObj);
+
+        bool isArray;
+        if (!JS_IsArrayObject(cx, whitelistObj, &isArray))
+            return false;
+
+        if (!isArray) {
+            JS_ReportErrorASCII(cx, "Whitelist must be an array.");
+            return false;
+        }
+
+        uint32_t length;
+        if (!JS_GetArrayLength(cx, whitelistObj, &length))
+            return false;
+
+        for (uint32_t i = 0; i < length; i++) {
+            RootedValue idval(cx);
+            if (!JS_GetElement(cx, whitelistObj, i, &idval))
+                return false;
+
+            if (!idval.isString()) {
+                JS_ReportErrorASCII(cx, "Whitelist must contain strings only.");
+                return false;
+            }
+
+            RootedString str(cx, idval.toString());
+            str = JS_AtomizeAndPinJSString(cx, str);
+            if (!str) {
+                JS_ReportErrorASCII(cx, "String internization failed.");
+                return false;
+            }
+
+            // By internizing the id's we ensure that they won't get
+            // GCed so we can use them as hash keys.
+            jsid id = INTERNED_STRING_TO_JSID(cx, str);
+            if (!whitelist->put(JSID_BITS(id))) {
+                JS_ReportOutOfMemory(cx);
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+/***************************************************************************/
+
+// static
+void
+XPCWrappedNativeScope::DebugDumpAllScopes(int16_t depth)
+{
+#ifdef DEBUG
+    depth-- ;
+
+    // get scope count.
+    int count = 0;
+    XPCWrappedNativeScope* cur;
+    for (cur = gScopes; cur; cur = cur->mNext)
+        count++ ;
+
+    XPC_LOG_ALWAYS(("chain of %d XPCWrappedNativeScope(s)", count));
+    XPC_LOG_INDENT();
+        XPC_LOG_ALWAYS(("gDyingScopes @ %x", gDyingScopes));
+        if (depth)
+            for (cur = gScopes; cur; cur = cur->mNext)
+                cur->DebugDump(depth);
+    XPC_LOG_OUTDENT();
+#endif
+}
+
+void
+XPCWrappedNativeScope::DebugDump(int16_t depth)
+{
+#ifdef DEBUG
+    depth-- ;
+    XPC_LOG_ALWAYS(("XPCWrappedNativeScope @ %x", this));
+    XPC_LOG_INDENT();
+        XPC_LOG_ALWAYS(("mNext @ %x", mNext));
+        XPC_LOG_ALWAYS(("mComponents @ %x", mComponents.get()));
+        XPC_LOG_ALWAYS(("mGlobalJSObject @ %x", mGlobalJSObject.get()));
+
+        XPC_LOG_ALWAYS(("mWrappedNativeMap @ %x with %d wrappers(s)",
+                        mWrappedNativeMap, mWrappedNativeMap->Count()));
+        // iterate contexts...
+        if (depth && mWrappedNativeMap->Count()) {
+            XPC_LOG_INDENT();
+            for (auto i = mWrappedNativeMap->Iter(); !i.Done(); i.Next()) {
+                auto entry = static_cast<Native2WrappedNativeMap::Entry*>(i.Get());
+                entry->value->DebugDump(depth);
+            }
+            XPC_LOG_OUTDENT();
+        }
+
+        XPC_LOG_ALWAYS(("mWrappedNativeProtoMap @ %x with %d protos(s)",
+                        mWrappedNativeProtoMap,
+                        mWrappedNativeProtoMap->Count()));
+        // iterate contexts...
+        if (depth && mWrappedNativeProtoMap->Count()) {
+            XPC_LOG_INDENT();
+            for (auto i = mWrappedNativeProtoMap->Iter(); !i.Done(); i.Next()) {
+                auto entry = static_cast<ClassInfo2WrappedNativeProtoMap::Entry*>(i.Get());
+                entry->value->DebugDump(depth);
+            }
+            XPC_LOG_OUTDENT();
+        }
+    XPC_LOG_OUTDENT();
+#endif
+}
+
+void
+XPCWrappedNativeScope::AddSizeOfAllScopesIncludingThis(ScopeSizeInfo* scopeSizeInfo)
+{
+    for (XPCWrappedNativeScope* cur = gScopes; cur; cur = cur->mNext)
+        cur->AddSizeOfIncludingThis(scopeSizeInfo);
+}
+
+void
+XPCWrappedNativeScope::AddSizeOfIncludingThis(ScopeSizeInfo* scopeSizeInfo)
+{
+    scopeSizeInfo->mScopeAndMapSize += scopeSizeInfo->mMallocSizeOf(this);
+    scopeSizeInfo->mScopeAndMapSize +=
+        mWrappedNativeMap->SizeOfIncludingThis(scopeSizeInfo->mMallocSizeOf);
+    scopeSizeInfo->mScopeAndMapSize +=
+        mWrappedNativeProtoMap->SizeOfIncludingThis(scopeSizeInfo->mMallocSizeOf);
+
+    if (dom::HasProtoAndIfaceCache(mGlobalJSObject)) {
+        dom::ProtoAndIfaceCache* cache = dom::GetProtoAndIfaceCache(mGlobalJSObject);
+        scopeSizeInfo->mProtoAndIfaceCacheSize +=
+            cache->SizeOfIncludingThis(scopeSizeInfo->mMallocSizeOf);
+    }
+
+    // There are other XPCWrappedNativeScope members that could be measured;
+    // the above ones have been seen by DMD to be worth measuring.  More stuff
+    // may be added later.
+}
diff --git a/js/xpconnect/src/XPCWrapper.cpp b/js/xpconnect/src/XPCWrapper.cpp
new file mode 100644
index 000000000..a6b331017
--- /dev/null
+++ b/js/xpconnect/src/XPCWrapper.cpp
@@ -0,0 +1,97 @@
+/* -*- 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 "xpcprivate.h"
+#include "XPCWrapper.h"
+#include "WrapperFactory.h"
+#include "AccessCheck.h"
+
+using namespace xpc;
+using namespace mozilla;
+using namespace JS;
+
+namespace XPCNativeWrapper {
+
+static inline
+bool
+ThrowException(nsresult ex, JSContext* cx)
+{
+  XPCThrower::Throw(ex, cx);
+
+  return false;
+}
+
+static bool
+UnwrapNW(JSContext* cx, unsigned argc, Value* vp)
+{
+  JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+  if (args.length() != 1) {
+    return ThrowException(NS_ERROR_XPC_NOT_ENOUGH_ARGS, cx);
+  }
+
+  JS::RootedValue v(cx, args[0]);
+  if (!v.isObject() || !js::IsCrossCompartmentWrapper(&v.toObject()) ||
+      !WrapperFactory::AllowWaiver(&v.toObject())) {
+    args.rval().set(v);
+    return true;
+  }
+
+  bool ok = xpc::WrapperFactory::WaiveXrayAndWrap(cx, &v);
+  NS_ENSURE_TRUE(ok, false);
+  args.rval().set(v);
+  return true;
+}
+
+static bool
+XrayWrapperConstructor(JSContext* cx, unsigned argc, Value* vp)
+{
+  JS::CallArgs args = CallArgsFromVp(argc, vp);
+  if (args.length() == 0) {
+    return ThrowException(NS_ERROR_XPC_NOT_ENOUGH_ARGS, cx);
+  }
+
+  if (!args[0].isObject()) {
+    args.rval().set(args[0]);
+    return true;
+  }
+
+  args.rval().setObject(*js::UncheckedUnwrap(&args[0].toObject()));
+  return JS_WrapValue(cx, args.rval());
+}
+// static
+bool
+AttachNewConstructorObject(JSContext* aCx, JS::HandleObject aGlobalObject)
+{
+  // Pushing a JSContext calls ActivateDebugger which calls this function, so
+  // we can't use an AutoJSContext here until JSD is gone.
+  JSAutoCompartment ac(aCx, aGlobalObject);
+  JSFunction* xpcnativewrapper =
+    JS_DefineFunction(aCx, aGlobalObject, "XPCNativeWrapper",
+                      XrayWrapperConstructor, 1,
+                      JSPROP_READONLY | JSPROP_PERMANENT | JSFUN_STUB_GSOPS | JSFUN_CONSTRUCTOR);
+  if (!xpcnativewrapper) {
+    return false;
+  }
+  JS::RootedObject obj(aCx, JS_GetFunctionObject(xpcnativewrapper));
+  return JS_DefineFunction(aCx, obj, "unwrap", UnwrapNW, 1,
+                           JSPROP_READONLY | JSPROP_PERMANENT) != nullptr;
+}
+
+} // namespace XPCNativeWrapper
+
+namespace XPCWrapper {
+
+JSObject*
+UnsafeUnwrapSecurityWrapper(JSObject* obj)
+{
+  if (js::IsProxy(obj)) {
+    return js::UncheckedUnwrap(obj);
+  }
+
+  return obj;
+}
+
+} // namespace XPCWrapper
diff --git a/js/xpconnect/src/XPCWrapper.h b/js/xpconnect/src/XPCWrapper.h
new file mode 100644
index 000000000..7e0ed8c1f
--- /dev/null
+++ b/js/xpconnect/src/XPCWrapper.h
@@ -0,0 +1,40 @@
+/* -*- 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 XPC_WRAPPER_H
+#define XPC_WRAPPER_H 1
+
+#include "js/TypeDecls.h"
+
+namespace XPCNativeWrapper {
+
+// Given an XPCWrappedNative pointer and the name of the function on
+// XPCNativeScriptableFlags corresponding with a flag, returns 'true'
+// if the flag is set.
+// XXX Convert to using GetFlags() and not a macro.
+#define NATIVE_HAS_FLAG(_wn, _flag)                                           \
+  ((_wn)->GetScriptableInfo() &&                                              \
+   (_wn)->GetScriptableInfo()->GetFlags()._flag())
+
+bool
+AttachNewConstructorObject(JSContext* aCx, JS::HandleObject aGlobalObject);
+
+} // namespace XPCNativeWrapper
+
+// This namespace wraps some common functionality between the three existing
+// wrappers. Its main purpose is to allow XPCCrossOriginWrapper to act both
+// as an XPCSafeJSObjectWrapper and as an XPCNativeWrapper when required to
+// do so (the decision is based on the principals of the wrapper and wrapped
+// objects).
+namespace XPCWrapper {
+
+JSObject*
+UnsafeUnwrapSecurityWrapper(JSObject* obj);
+
+} // namespace XPCWrapper
+
+
+#endif
diff --git a/js/xpconnect/src/jsshell.msg b/js/xpconnect/src/jsshell.msg
new file mode 100644
index 000000000..078d75e28
--- /dev/null
+++ b/js/xpconnect/src/jsshell.msg
@@ -0,0 +1,12 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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/. */
+
+/*
+	Error messages for JSShell. See js.msg for format.
+*/
+
+MSG_DEF(JSSMSG_NOT_AN_ERROR,             0, 0, JSEXN_ERR, "<Error #0 is reserved>")
+MSG_DEF(JSSMSG_CANT_OPEN,                1, 2, JSEXN_ERR, "can't open {0}: {1}") 
diff --git a/js/xpconnect/src/moz.build b/js/xpconnect/src/moz.build
new file mode 100644
index 000000000..7e787bb56
--- /dev/null
+++ b/js/xpconnect/src/moz.build
@@ -0,0 +1,70 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+EXPORTS += [
+    'BackstagePass.h',
+    'qsObjectHelper.h',
+    'XPCJSMemoryReporter.h',
+    'xpcObjectHelper.h',
+    'xpcpublic.h',
+]
+
+UNIFIED_SOURCES += [
+    'ExportHelpers.cpp',
+    'nsScriptError.cpp',
+    'nsScriptErrorWithStack.cpp',
+    'nsXPConnect.cpp',
+    'Sandbox.cpp',
+    'XPCCallContext.cpp',
+    'XPCConvert.cpp',
+    'XPCDebug.cpp',
+    'XPCException.cpp',
+    'XPCJSContext.cpp',
+    'XPCJSID.cpp',
+    'XPCJSWeakReference.cpp',
+    'XPCLocale.cpp',
+    'XPCLog.cpp',
+    'XPCMaps.cpp',
+    'XPCModule.cpp',
+    'XPCRuntimeService.cpp',
+    'XPCShellImpl.cpp',
+    'XPCString.cpp',
+    'XPCThrower.cpp',
+    'XPCVariant.cpp',
+    'XPCWrappedJS.cpp',
+    'XPCWrappedJSClass.cpp',
+    'XPCWrappedNative.cpp',
+    'XPCWrappedNativeInfo.cpp',
+    'XPCWrappedNativeJSOps.cpp',
+    'XPCWrappedNativeProto.cpp',
+    'XPCWrappedNativeScope.cpp',
+    'XPCWrapper.cpp',
+]
+
+# XPCComponents.cpp cannot be built in unified mode because it uses plarena.h.
+SOURCES += [
+    'XPCComponents.cpp',
+]
+
+include('/ipc/chromium/chromium-config.mozbuild')
+
+FINAL_LIBRARY = 'xul'
+
+LOCAL_INCLUDES += [
+    '../loader',
+    '../wrappers',
+    '/caps',
+    '/dom/base',
+    '/dom/html',
+    '/dom/svg',
+    '/dom/workers',
+    '/layout/base',
+    '/layout/style',
+    '/xpcom/reflect/xptinfo',
+]
+
+if CONFIG['GNU_CXX']:
+    CXXFLAGS += ['-Wno-shadow', '-Werror=format']
diff --git a/js/xpconnect/src/nsScriptError.cpp b/js/xpconnect/src/nsScriptError.cpp
new file mode 100644
index 000000000..ff687bc44
--- /dev/null
+++ b/js/xpconnect/src/nsScriptError.cpp
@@ -0,0 +1,345 @@
+/* -*- 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/. */
+
+/*
+ * nsIScriptError implementation.  Defined here, lacking a JS-specific
+ * place to put XPCOM things.
+ */
+
+#include "xpcprivate.h"
+#include "jsprf.h"
+#include "MainThreadUtils.h"
+#include "mozilla/Assertions.h"
+#include "nsGlobalWindow.h"
+#include "nsPIDOMWindow.h"
+#include "nsILoadContext.h"
+#include "nsIDocShell.h"
+#include "nsIScriptError.h"
+#include "nsISensitiveInfoHiddenURI.h"
+
+static_assert(nsIScriptError::errorFlag == JSREPORT_ERROR &&
+              nsIScriptError::warningFlag == JSREPORT_WARNING &&
+              nsIScriptError::exceptionFlag == JSREPORT_EXCEPTION &&
+              nsIScriptError::strictFlag == JSREPORT_STRICT &&
+              nsIScriptError::infoFlag == JSREPORT_USER_1,
+              "flags should be consistent");
+
+nsScriptErrorBase::nsScriptErrorBase()
+    :  mMessage(),
+       mMessageName(),
+       mSourceName(),
+       mLineNumber(0),
+       mSourceLine(),
+       mColumnNumber(0),
+       mFlags(0),
+       mCategory(),
+       mOuterWindowID(0),
+       mInnerWindowID(0),
+       mTimeStamp(0),
+       mInitializedOnMainThread(false),
+       mIsFromPrivateWindow(false)
+{
+}
+
+nsScriptErrorBase::~nsScriptErrorBase() {}
+
+void
+nsScriptErrorBase::InitializeOnMainThread()
+{
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(!mInitializedOnMainThread);
+
+    if (mInnerWindowID) {
+        nsGlobalWindow* window =
+          nsGlobalWindow::GetInnerWindowWithId(mInnerWindowID);
+        if (window) {
+            nsPIDOMWindowOuter* outer = window->GetOuterWindow();
+            if (outer)
+                mOuterWindowID = outer->WindowID();
+
+            nsIDocShell* docShell = window->GetDocShell();
+            nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(docShell);
+
+            if (loadContext) {
+                // Never mark exceptions from chrome windows as having come from
+                // private windows, since we always want them to be reported.
+                nsIPrincipal* winPrincipal = window->GetPrincipal();
+                mIsFromPrivateWindow = loadContext->UsePrivateBrowsing() &&
+                                       !nsContentUtils::IsSystemPrincipal(winPrincipal);
+            }
+        }
+    }
+
+    mInitializedOnMainThread = true;
+}
+
+// nsIConsoleMessage methods
+NS_IMETHODIMP
+nsScriptErrorBase::GetMessageMoz(char16_t** result) {
+    nsresult rv;
+
+    nsAutoCString message;
+    rv = ToString(message);
+    if (NS_FAILED(rv))
+        return rv;
+
+    *result = UTF8ToNewUnicode(message);
+    if (!*result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetLogLevel(uint32_t* aLogLevel)
+{
+  if (mFlags & (uint32_t)nsIScriptError::infoFlag) {
+    *aLogLevel = nsIConsoleMessage::info;
+  } else if (mFlags & (uint32_t)nsIScriptError::warningFlag) {
+    *aLogLevel = nsIConsoleMessage::warn;
+  } else {
+    *aLogLevel = nsIConsoleMessage::error;
+  }
+  return NS_OK;
+}
+
+// nsIScriptError methods
+NS_IMETHODIMP
+nsScriptErrorBase::GetErrorMessage(nsAString& aResult) {
+    aResult.Assign(mMessage);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetSourceName(nsAString& aResult) {
+    aResult.Assign(mSourceName);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetSourceLine(nsAString& aResult) {
+    aResult.Assign(mSourceLine);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetLineNumber(uint32_t* result) {
+    *result = mLineNumber;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetColumnNumber(uint32_t* result) {
+    *result = mColumnNumber;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetFlags(uint32_t* result) {
+    *result = mFlags;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetCategory(char** result) {
+    *result = ToNewCString(mCategory);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetStack(JS::MutableHandleValue aStack) {
+    aStack.setUndefined();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::SetStack(JS::HandleValue aStack) {
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetErrorMessageName(nsAString& aErrorMessageName) {
+    aErrorMessageName = mMessageName;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::SetErrorMessageName(const nsAString& aErrorMessageName) {
+    mMessageName = aErrorMessageName;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::Init(const nsAString& message,
+                        const nsAString& sourceName,
+                        const nsAString& sourceLine,
+                        uint32_t lineNumber,
+                        uint32_t columnNumber,
+                        uint32_t flags,
+                        const char* category)
+{
+    return InitWithWindowID(message, sourceName, sourceLine, lineNumber,
+                            columnNumber, flags,
+                            category ? nsDependentCString(category)
+                                     : EmptyCString(),
+                            0);
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::InitWithWindowID(const nsAString& message,
+                                    const nsAString& sourceName,
+                                    const nsAString& sourceLine,
+                                    uint32_t lineNumber,
+                                    uint32_t columnNumber,
+                                    uint32_t flags,
+                                    const nsACString& category,
+                                    uint64_t aInnerWindowID)
+{
+    mMessage.Assign(message);
+
+    if (!sourceName.IsEmpty()) {
+        mSourceName.Assign(sourceName);
+
+        nsCOMPtr<nsIURI> uri;
+        nsAutoCString pass;
+        if (NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), sourceName)) &&
+            NS_SUCCEEDED(uri->GetPassword(pass)) &&
+            !pass.IsEmpty()) {
+            nsCOMPtr<nsISensitiveInfoHiddenURI> safeUri =
+                do_QueryInterface(uri);
+
+            nsAutoCString loc;
+            if (safeUri &&
+                NS_SUCCEEDED(safeUri->GetSensitiveInfoHiddenSpec(loc))) {
+                mSourceName.Assign(NS_ConvertUTF8toUTF16(loc));
+            }
+        }
+    }
+
+    mLineNumber = lineNumber;
+    mSourceLine.Assign(sourceLine);
+    mColumnNumber = columnNumber;
+    mFlags = flags;
+    mCategory = category;
+    mTimeStamp = JS_Now() / 1000;
+    mInnerWindowID = aInnerWindowID;
+
+    if (aInnerWindowID && NS_IsMainThread()) {
+        InitializeOnMainThread();
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::ToString(nsACString& /*UTF8*/ aResult)
+{
+    static const char format0[] =
+        "[%s: \"%s\" {file: \"%s\" line: %d column: %d source: \"%s\"}]";
+    static const char format1[] =
+        "[%s: \"%s\" {file: \"%s\" line: %d}]";
+    static const char format2[] =
+        "[%s: \"%s\"]";
+
+    static const char error[]   = "JavaScript Error";
+    static const char warning[] = "JavaScript Warning";
+
+    const char* severity = !(mFlags & JSREPORT_WARNING) ? error : warning;
+
+    char* temp;
+    char* tempMessage = nullptr;
+    char* tempSourceName = nullptr;
+    char* tempSourceLine = nullptr;
+
+    if (!mMessage.IsEmpty())
+        tempMessage = ToNewUTF8String(mMessage);
+    if (!mSourceName.IsEmpty())
+        // Use at most 512 characters from mSourceName.
+        tempSourceName = ToNewUTF8String(StringHead(mSourceName, 512));
+    if (!mSourceLine.IsEmpty())
+        // Use at most 512 characters from mSourceLine.
+        tempSourceLine = ToNewUTF8String(StringHead(mSourceLine, 512));
+
+    if (nullptr != tempSourceName && nullptr != tempSourceLine)
+        temp = JS_smprintf(format0,
+                           severity,
+                           tempMessage,
+                           tempSourceName,
+                           mLineNumber,
+                           mColumnNumber,
+                           tempSourceLine);
+    else if (!mSourceName.IsEmpty())
+        temp = JS_smprintf(format1,
+                           severity,
+                           tempMessage,
+                           tempSourceName,
+                           mLineNumber);
+    else
+        temp = JS_smprintf(format2,
+                           severity,
+                           tempMessage);
+
+    if (nullptr != tempMessage)
+        free(tempMessage);
+    if (nullptr != tempSourceName)
+        free(tempSourceName);
+    if (nullptr != tempSourceLine)
+        free(tempSourceLine);
+
+    if (!temp)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    aResult.Assign(temp);
+    JS_smprintf_free(temp);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetOuterWindowID(uint64_t* aOuterWindowID)
+{
+    NS_WARNING_ASSERTION(NS_IsMainThread() || mInitializedOnMainThread,
+                         "This can't be safely determined off the main thread, "
+                         "returning an inaccurate value!");
+
+    if (!mInitializedOnMainThread && NS_IsMainThread()) {
+        InitializeOnMainThread();
+    }
+
+    *aOuterWindowID = mOuterWindowID;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetInnerWindowID(uint64_t* aInnerWindowID)
+{
+    *aInnerWindowID = mInnerWindowID;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetTimeStamp(int64_t* aTimeStamp)
+{
+    *aTimeStamp = mTimeStamp;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorBase::GetIsFromPrivateWindow(bool* aIsFromPrivateWindow)
+{
+    NS_WARNING_ASSERTION(NS_IsMainThread() || mInitializedOnMainThread,
+                         "This can't be safely determined off the main thread, "
+                         "returning an inaccurate value!");
+
+    if (!mInitializedOnMainThread && NS_IsMainThread()) {
+        InitializeOnMainThread();
+    }
+
+    *aIsFromPrivateWindow = mIsFromPrivateWindow;
+    return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsScriptError, nsIConsoleMessage, nsIScriptError)
diff --git a/js/xpconnect/src/nsScriptErrorWithStack.cpp b/js/xpconnect/src/nsScriptErrorWithStack.cpp
new file mode 100644
index 000000000..edc12fa76
--- /dev/null
+++ b/js/xpconnect/src/nsScriptErrorWithStack.cpp
@@ -0,0 +1,119 @@
+/* -*- 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/. */
+
+/*
+ * nsScriptErrorWithStack implementation.
+ * a main-thread-only, cycle-collected subclass of nsScriptErrorBase
+ * that can store a SavedFrame stack trace object.
+ */
+
+#include "xpcprivate.h"
+#include "MainThreadUtils.h"
+#include "mozilla/Assertions.h"
+#include "nsGlobalWindow.h"
+#include "nsCycleCollectionParticipant.h"
+
+
+namespace {
+
+static nsCString
+FormatStackString(JSContext* cx, HandleObject aStack) {
+    JS::RootedString formattedStack(cx);
+
+    if (!JS::BuildStackString(cx, aStack, &formattedStack)) {
+        return nsCString();
+    }
+
+    nsAutoJSString stackJSString;
+    if (!stackJSString.init(cx, formattedStack)) {
+        return nsCString();
+    }
+
+    return NS_ConvertUTF16toUTF8(stackJSString.get());
+}
+
+}
+
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsScriptErrorWithStack)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsScriptErrorWithStack)
+  tmp->mStack = nullptr;
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsScriptErrorWithStack)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsScriptErrorWithStack)
+  NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mStack)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsScriptErrorWithStack)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsScriptErrorWithStack)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsScriptErrorWithStack)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+  NS_INTERFACE_MAP_ENTRY(nsIConsoleMessage)
+  NS_INTERFACE_MAP_ENTRY(nsIScriptError)
+NS_INTERFACE_MAP_END
+
+nsScriptErrorWithStack::nsScriptErrorWithStack(JS::HandleObject aStack)
+  : mStack(aStack)
+{
+    MOZ_ASSERT(NS_IsMainThread(), "You can't use this class on workers.");
+    mozilla::HoldJSObjects(this);
+}
+
+nsScriptErrorWithStack::~nsScriptErrorWithStack() {
+    mozilla::DropJSObjects(this);
+}
+
+NS_IMETHODIMP
+nsScriptErrorWithStack::Init(const nsAString& message,
+                             const nsAString& sourceName,
+                             const nsAString& sourceLine,
+                             uint32_t lineNumber,
+                             uint32_t columnNumber,
+                             uint32_t flags,
+                             const char* category)
+{
+  MOZ_CRASH("nsScriptErrorWithStack requires to be initialized with a document, by using InitWithWindowID");
+}
+
+NS_IMETHODIMP
+nsScriptErrorWithStack::GetStack(JS::MutableHandleValue aStack) {
+    aStack.setObjectOrNull(mStack);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsScriptErrorWithStack::ToString(nsACString& /*UTF8*/ aResult)
+{
+    MOZ_ASSERT(NS_IsMainThread());
+
+    nsCString message;
+    nsresult rv = nsScriptErrorBase::ToString(message);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!mStack) {
+        aResult.Assign(message);
+        return NS_OK;
+    }
+
+    AutoJSAPI jsapi;
+    if (!jsapi.Init(mStack)) {
+        return NS_ERROR_FAILURE;
+    }
+
+    JSContext* cx = jsapi.cx();
+    RootedObject stack(cx, mStack);
+    nsCString stackString = FormatStackString(cx, stack);
+    nsCString combined = message + NS_LITERAL_CSTRING("\n") + stackString;
+    aResult.Assign(combined);
+
+    return NS_OK;
+}
diff --git a/js/xpconnect/src/nsXPConnect.cpp b/js/xpconnect/src/nsXPConnect.cpp
new file mode 100644
index 000000000..0466175b1
--- /dev/null
+++ b/js/xpconnect/src/nsXPConnect.cpp
@@ -0,0 +1,1336 @@
+/* -*- 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/. */
+
+/* High level class and public functions implementation. */
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Base64.h"
+#include "mozilla/Likely.h"
+#include "mozilla/Unused.h"
+
+#include "xpcprivate.h"
+#include "XPCWrapper.h"
+#include "jsfriendapi.h"
+#include "nsJSEnvironment.h"
+#include "nsThreadUtils.h"
+#include "nsDOMJSUtils.h"
+
+#include "WrapperFactory.h"
+#include "AccessCheck.h"
+
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/Exceptions.h"
+#include "mozilla/dom/Promise.h"
+
+#include "nsDOMMutationObserver.h"
+#include "nsICycleCollectorListener.h"
+#include "mozilla/XPTInterfaceInfoManager.h"
+#include "nsIObjectInputStream.h"
+#include "nsIObjectOutputStream.h"
+#include "nsScriptSecurityManager.h"
+#include "nsIPermissionManager.h"
+#include "nsContentUtils.h"
+#include "jsfriendapi.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace xpc;
+using namespace JS;
+
+NS_IMPL_ISUPPORTS(nsXPConnect, nsIXPConnect)
+
+nsXPConnect* nsXPConnect::gSelf = nullptr;
+bool         nsXPConnect::gOnceAliveNowDead = false;
+
+// Global cache of the default script security manager (QI'd to
+// nsIScriptSecurityManager) and the system principal.
+nsIScriptSecurityManager* nsXPConnect::gScriptSecurityManager = nullptr;
+nsIPrincipal* nsXPConnect::gSystemPrincipal = nullptr;
+
+const char XPC_CONTEXT_STACK_CONTRACTID[] = "@mozilla.org/js/xpc/ContextStack;1";
+const char XPC_EXCEPTION_CONTRACTID[]     = "@mozilla.org/js/xpc/Exception;1";
+const char XPC_CONSOLE_CONTRACTID[]       = "@mozilla.org/consoleservice;1";
+const char XPC_SCRIPT_ERROR_CONTRACTID[]  = "@mozilla.org/scripterror;1";
+const char XPC_ID_CONTRACTID[]            = "@mozilla.org/js/xpc/ID;1";
+const char XPC_XPCONNECT_CONTRACTID[]     = "@mozilla.org/js/xpc/XPConnect;1";
+
+/***************************************************************************/
+
+nsXPConnect::nsXPConnect()
+    :   mContext(nullptr),
+        mShuttingDown(false)
+{
+    mContext = XPCJSContext::newXPCJSContext();
+    if (!mContext) {
+        NS_RUNTIMEABORT("Couldn't create XPCJSContext.");
+    }
+}
+
+nsXPConnect::~nsXPConnect()
+{
+    mContext->DeleteSingletonScopes();
+
+    // In order to clean up everything properly, we need to GC twice: once now,
+    // to clean anything that can go away on its own (like the Junk Scope, which
+    // we unrooted above), and once after forcing a bunch of shutdown in
+    // XPConnect, to clean the stuff we forcibly disconnected. The forced
+    // shutdown code defaults to leaking in a number of situations, so we can't
+    // get by with only the second GC. :-(
+    mContext->GarbageCollect(JS::gcreason::XPCONNECT_SHUTDOWN);
+
+    mShuttingDown = true;
+    XPCWrappedNativeScope::SystemIsBeingShutDown();
+
+    // The above causes us to clean up a bunch of XPConnect data structures,
+    // after which point we need to GC to clean everything up. We need to do
+    // this before deleting the XPCJSContext, because doing so destroys the
+    // maps that our finalize callback depends on.
+    mContext->GarbageCollect(JS::gcreason::XPCONNECT_SHUTDOWN);
+
+    NS_RELEASE(gSystemPrincipal);
+    gScriptSecurityManager = nullptr;
+
+    // shutdown the logging system
+    XPC_LOG_FINISH();
+
+    delete mContext;
+
+    gSelf = nullptr;
+    gOnceAliveNowDead = true;
+}
+
+// static
+void
+nsXPConnect::InitStatics()
+{
+    gSelf = new nsXPConnect();
+    gOnceAliveNowDead = false;
+    if (!gSelf->mContext) {
+        NS_RUNTIMEABORT("Couldn't create XPCJSContext.");
+    }
+
+    // Initial extra ref to keep the singleton alive
+    // balanced by explicit call to ReleaseXPConnectSingleton()
+    NS_ADDREF(gSelf);
+
+    // Fire up the SSM.
+    nsScriptSecurityManager::InitStatics();
+    gScriptSecurityManager = nsScriptSecurityManager::GetScriptSecurityManager();
+    gScriptSecurityManager->GetSystemPrincipal(&gSystemPrincipal);
+    MOZ_RELEASE_ASSERT(gSystemPrincipal);
+
+    if (!JS::InitSelfHostedCode(gSelf->mContext->Context()))
+        MOZ_CRASH("InitSelfHostedCode failed");
+    if (!gSelf->mContext->JSContextInitialized(gSelf->mContext->Context()))
+        MOZ_CRASH("JSContextInitialized failed");
+
+    // Initialize our singleton scopes.
+    gSelf->mContext->InitSingletonScopes();
+}
+
+nsXPConnect*
+nsXPConnect::GetSingleton()
+{
+    nsXPConnect* xpc = nsXPConnect::XPConnect();
+    NS_IF_ADDREF(xpc);
+    return xpc;
+}
+
+// static
+void
+nsXPConnect::ReleaseXPConnectSingleton()
+{
+    nsXPConnect* xpc = gSelf;
+    if (xpc) {
+        nsrefcnt cnt;
+        NS_RELEASE2(xpc, cnt);
+    }
+}
+
+// static
+XPCJSContext*
+nsXPConnect::GetContextInstance()
+{
+    nsXPConnect* xpc = XPConnect();
+    return xpc->GetContext();
+}
+
+// static
+bool
+nsXPConnect::IsISupportsDescendant(nsIInterfaceInfo* info)
+{
+    bool found = false;
+    if (info)
+        info->HasAncestor(&NS_GET_IID(nsISupports), &found);
+    return found;
+}
+
+void
+xpc::ErrorReport::Init(JSErrorReport* aReport, const char* aToStringResult,
+                       bool aIsChrome, uint64_t aWindowID)
+{
+    mCategory = aIsChrome ? NS_LITERAL_CSTRING("chrome javascript")
+                          : NS_LITERAL_CSTRING("content javascript");
+    mWindowID = aWindowID;
+
+    ErrorReportToMessageString(aReport, mErrorMsg);
+    if (mErrorMsg.IsEmpty() && aToStringResult) {
+        AppendUTF8toUTF16(aToStringResult, mErrorMsg);
+    }
+
+    if (!aReport->filename) {
+        mFileName.SetIsVoid(true);
+    } else {
+        mFileName.AssignWithConversion(aReport->filename);
+    }
+
+    mSourceLine.Assign(aReport->linebuf(), aReport->linebufLength());
+    const JSErrorFormatString* efs = js::GetErrorMessage(nullptr, aReport->errorNumber);
+
+    if (efs == nullptr) {
+        mErrorMsgName.AssignASCII("");
+    } else {
+        mErrorMsgName.AssignASCII(efs->name);
+    }
+
+    mLineNumber = aReport->lineno;
+    mColumn = aReport->column;
+    mFlags = aReport->flags;
+    mIsMuted = aReport->isMuted;
+}
+
+void
+xpc::ErrorReport::Init(JSContext* aCx, mozilla::dom::Exception* aException,
+                       bool aIsChrome, uint64_t aWindowID)
+{
+    mCategory = aIsChrome ? NS_LITERAL_CSTRING("chrome javascript")
+                          : NS_LITERAL_CSTRING("content javascript");
+    mWindowID = aWindowID;
+
+    aException->GetErrorMessage(mErrorMsg);
+
+    aException->GetFilename(aCx, mFileName);
+    if (mFileName.IsEmpty()) {
+      mFileName.SetIsVoid(true);
+    }
+    aException->GetLineNumber(aCx, &mLineNumber);
+    aException->GetColumnNumber(&mColumn);
+
+    mFlags = JSREPORT_EXCEPTION;
+}
+
+static LazyLogModule gJSDiagnostics("JSDiagnostics");
+
+void
+xpc::ErrorReport::LogToConsole()
+{
+  LogToConsoleWithStack(nullptr);
+}
+void
+xpc::ErrorReport::LogToConsoleWithStack(JS::HandleObject aStack)
+{
+    // Log to stdout.
+    if (nsContentUtils::DOMWindowDumpEnabled()) {
+        nsAutoCString error;
+        error.AssignLiteral("JavaScript ");
+        if (JSREPORT_IS_STRICT(mFlags))
+            error.AppendLiteral("strict ");
+        if (JSREPORT_IS_WARNING(mFlags))
+            error.AppendLiteral("warning: ");
+        else
+            error.AppendLiteral("error: ");
+        error.Append(NS_LossyConvertUTF16toASCII(mFileName));
+        error.AppendLiteral(", line ");
+        error.AppendInt(mLineNumber, 10);
+        error.AppendLiteral(": ");
+        error.Append(NS_LossyConvertUTF16toASCII(mErrorMsg));
+
+        fprintf(stderr, "%s\n", error.get());
+        fflush(stderr);
+    }
+
+    MOZ_LOG(gJSDiagnostics,
+            JSREPORT_IS_WARNING(mFlags) ? LogLevel::Warning : LogLevel::Error,
+            ("file %s, line %u\n%s", NS_LossyConvertUTF16toASCII(mFileName).get(),
+             mLineNumber, NS_LossyConvertUTF16toASCII(mErrorMsg).get()));
+
+    // Log to the console. We do this last so that we can simply return if
+    // there's no console service without affecting the other reporting
+    // mechanisms.
+    nsCOMPtr<nsIConsoleService> consoleService =
+      do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+
+    nsCOMPtr<nsIScriptError> errorObject;
+    if (mWindowID && aStack) {
+      // Only set stack on messages related to a document
+      // As we cache messages in the console service,
+      // we have to ensure not leaking them after the related
+      // context is destroyed and we only track document lifecycle for now.
+      errorObject = new nsScriptErrorWithStack(aStack);
+    } else {
+      errorObject = new nsScriptError();
+    }
+    errorObject->SetErrorMessageName(mErrorMsgName);
+    NS_ENSURE_TRUE_VOID(consoleService);
+
+    nsresult rv = errorObject->InitWithWindowID(mErrorMsg, mFileName, mSourceLine,
+                                                mLineNumber, mColumn, mFlags,
+                                                mCategory, mWindowID);
+    NS_ENSURE_SUCCESS_VOID(rv);
+    consoleService->LogMessage(errorObject);
+
+}
+
+/* static */
+void
+xpc::ErrorReport::ErrorReportToMessageString(JSErrorReport* aReport,
+                                             nsAString& aString)
+{
+    aString.Truncate();
+    if (aReport->message()) {
+        JSFlatString* name = js::GetErrorTypeName(CycleCollectedJSContext::Get()->Context(), aReport->exnType);
+        if (name) {
+            AssignJSFlatString(aString, name);
+            aString.AppendLiteral(": ");
+        }
+        aString.Append(NS_ConvertUTF8toUTF16(aReport->message().c_str()));
+    }
+}
+
+/***************************************************************************/
+
+
+nsresult
+nsXPConnect::GetInfoForIID(const nsIID * aIID, nsIInterfaceInfo** info)
+{
+  return XPTInterfaceInfoManager::GetSingleton()->GetInfoForIID(aIID, info);
+}
+
+nsresult
+nsXPConnect::GetInfoForName(const char * name, nsIInterfaceInfo** info)
+{
+  nsresult rv = XPTInterfaceInfoManager::GetSingleton()->GetInfoForName(name, info);
+  return NS_FAILED(rv) ? NS_OK : NS_ERROR_NO_INTERFACE;
+}
+
+NS_IMETHODIMP
+nsXPConnect::GarbageCollect(uint32_t reason)
+{
+    GetContext()->GarbageCollect(reason);
+    return NS_OK;
+}
+
+void
+xpc_MarkInCCGeneration(nsISupports* aVariant, uint32_t aGeneration)
+{
+    nsCOMPtr<XPCVariant> variant = do_QueryInterface(aVariant);
+    if (variant) {
+        variant->SetCCGeneration(aGeneration);
+        variant->GetJSVal(); // Unmarks gray JSObject.
+        XPCVariant* weak = variant.get();
+        variant = nullptr;
+        if (weak->IsPurple()) {
+          weak->RemovePurple();
+        }
+    }
+}
+
+void
+xpc_TryUnmarkWrappedGrayObject(nsISupports* aWrappedJS)
+{
+    // QIing to nsIXPConnectWrappedJSUnmarkGray may have side effects!
+    nsCOMPtr<nsIXPConnectWrappedJSUnmarkGray> wjsug =
+      do_QueryInterface(aWrappedJS);
+    Unused << wjsug;
+    MOZ_ASSERT(!wjsug, "One should never be able to QI to "
+                       "nsIXPConnectWrappedJSUnmarkGray successfully!");
+}
+
+/***************************************************************************/
+/***************************************************************************/
+// nsIXPConnect interface methods...
+
+template<typename T>
+static inline T UnexpectedFailure(T rv)
+{
+    NS_ERROR("This is not supposed to fail!");
+    return rv;
+}
+
+void
+xpc::TraceXPCGlobal(JSTracer* trc, JSObject* obj)
+{
+    if (js::GetObjectClass(obj)->flags & JSCLASS_DOM_GLOBAL)
+        mozilla::dom::TraceProtoAndIfaceCache(trc, obj);
+
+    // We might be called from a GC during the creation of a global, before we've
+    // been able to set up the compartment private or the XPCWrappedNativeScope,
+    // so we need to null-check those.
+    xpc::CompartmentPrivate* compartmentPrivate = xpc::CompartmentPrivate::Get(obj);
+    if (compartmentPrivate && compartmentPrivate->scope)
+        compartmentPrivate->scope->TraceInside(trc);
+}
+
+
+namespace xpc {
+
+JSObject*
+CreateGlobalObject(JSContext* cx, const JSClass* clasp, nsIPrincipal* principal,
+                   JS::CompartmentOptions& aOptions)
+{
+    MOZ_ASSERT(NS_IsMainThread(), "using a principal off the main thread?");
+    MOZ_ASSERT(principal);
+
+    MOZ_RELEASE_ASSERT(principal != nsContentUtils::GetNullSubjectPrincipal(),
+                       "The null subject principal is getting inherited - fix that!");
+
+    RootedObject global(cx,
+                        JS_NewGlobalObject(cx, clasp, nsJSPrincipals::get(principal),
+                                           JS::DontFireOnNewGlobalHook, aOptions));
+    if (!global)
+        return nullptr;
+    JSAutoCompartment ac(cx, global);
+
+    // The constructor automatically attaches the scope to the compartment private
+    // of |global|.
+    (void) new XPCWrappedNativeScope(cx, global);
+
+    if (clasp->flags & JSCLASS_DOM_GLOBAL) {
+#ifdef DEBUG
+        // Verify that the right trace hook is called. Note that this doesn't
+        // work right for wrapped globals, since the tracing situation there is
+        // more complicated. Manual inspection shows that they do the right
+        // thing.  Also note that we only check this for JSCLASS_DOM_GLOBAL
+        // classes because xpc::TraceXPCGlobal won't call
+        // TraceProtoAndIfaceCache unless that flag is set.
+        if (!((const js::Class*)clasp)->isWrappedNative())
+        {
+            VerifyTraceProtoAndIfaceCacheCalledTracer trc(cx);
+            TraceChildren(&trc, GCCellPtr(global.get()));
+            MOZ_ASSERT(trc.ok, "Trace hook on global needs to call TraceXPCGlobal for XPConnect compartments.");
+        }
+#endif
+
+        const char* className = clasp->name;
+        AllocateProtoAndIfaceCache(global,
+                                   (strcmp(className, "Window") == 0 ||
+                                    strcmp(className, "ChromeWindow") == 0)
+                                   ? ProtoAndIfaceCache::WindowLike
+                                   : ProtoAndIfaceCache::NonWindowLike);
+    }
+
+    return global;
+}
+
+void
+InitGlobalObjectOptions(JS::CompartmentOptions& aOptions,
+                        nsIPrincipal* aPrincipal)
+{
+    bool shouldDiscardSystemSource = ShouldDiscardSystemSource();
+    bool extraWarningsForSystemJS = ExtraWarningsForSystemJS();
+
+    bool isSystem = nsContentUtils::IsSystemPrincipal(aPrincipal);
+
+    if (isSystem) {
+        // Make sure [SecureContext] APIs are visible:
+        aOptions.creationOptions().setSecureContext(true);
+    }
+
+    if (shouldDiscardSystemSource) {
+        bool discardSource = isSystem;
+
+        aOptions.behaviors().setDiscardSource(discardSource);
+    }
+
+    if (extraWarningsForSystemJS) {
+        if (isSystem)
+            aOptions.behaviors().extraWarningsOverride().set(true);
+    }
+}
+
+bool
+InitGlobalObject(JSContext* aJSContext, JS::Handle<JSObject*> aGlobal, uint32_t aFlags)
+{
+    // Immediately enter the global's compartment so that everything we create
+    // ends up there.
+    JSAutoCompartment ac(aJSContext, aGlobal);
+
+    // Stuff coming through this path always ends up as a DOM global.
+    MOZ_ASSERT(js::GetObjectClass(aGlobal)->flags & JSCLASS_DOM_GLOBAL);
+
+    if (!(aFlags & nsIXPConnect::OMIT_COMPONENTS_OBJECT)) {
+        // XPCCallContext gives us an active request needed to save/restore.
+        if (!CompartmentPrivate::Get(aGlobal)->scope->AttachComponentsObject(aJSContext) ||
+            !XPCNativeWrapper::AttachNewConstructorObject(aJSContext, aGlobal)) {
+            return UnexpectedFailure(false);
+        }
+    }
+
+    if (!(aFlags & nsIXPConnect::DONT_FIRE_ONNEWGLOBALHOOK))
+        JS_FireOnNewGlobalObject(aJSContext, aGlobal);
+
+    return true;
+}
+
+} // namespace xpc
+
+NS_IMETHODIMP
+nsXPConnect::InitClassesWithNewWrappedGlobal(JSContext * aJSContext,
+                                             nsISupports* aCOMObj,
+                                             nsIPrincipal * aPrincipal,
+                                             uint32_t aFlags,
+                                             JS::CompartmentOptions& aOptions,
+                                             nsIXPConnectJSObjectHolder** _retval)
+{
+    MOZ_ASSERT(aJSContext, "bad param");
+    MOZ_ASSERT(aCOMObj, "bad param");
+    MOZ_ASSERT(_retval, "bad param");
+
+    // We pass null for the 'extra' pointer during global object creation, so
+    // we need to have a principal.
+    MOZ_ASSERT(aPrincipal);
+
+    InitGlobalObjectOptions(aOptions, aPrincipal);
+
+    // Call into XPCWrappedNative to make a new global object, scope, and global
+    // prototype.
+    xpcObjectHelper helper(aCOMObj);
+    MOZ_ASSERT(helper.GetScriptableFlags() & nsIXPCScriptable::IS_GLOBAL_OBJECT);
+    RefPtr<XPCWrappedNative> wrappedGlobal;
+    nsresult rv =
+        XPCWrappedNative::WrapNewGlobal(helper, aPrincipal,
+                                        aFlags & nsIXPConnect::INIT_JS_STANDARD_CLASSES,
+                                        aOptions, getter_AddRefs(wrappedGlobal));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Grab a copy of the global and enter its compartment.
+    RootedObject global(aJSContext, wrappedGlobal->GetFlatJSObject());
+    MOZ_ASSERT(JS_IsGlobalObject(global));
+
+    if (!InitGlobalObject(aJSContext, global, aFlags))
+        return UnexpectedFailure(NS_ERROR_FAILURE);
+
+    wrappedGlobal.forget(_retval);
+    return NS_OK;
+}
+
+static nsresult
+NativeInterface2JSObject(HandleObject aScope,
+                         nsISupports* aCOMObj,
+                         nsWrapperCache* aCache,
+                         const nsIID * aIID,
+                         bool aAllowWrapping,
+                         MutableHandleValue aVal,
+                         nsIXPConnectJSObjectHolder** aHolder)
+{
+    AutoJSContext cx;
+    JSAutoCompartment ac(cx, aScope);
+
+    nsresult rv;
+    xpcObjectHelper helper(aCOMObj, aCache);
+    if (!XPCConvert::NativeInterface2JSObject(aVal, aHolder, helper, aIID,
+                                              aAllowWrapping, &rv))
+        return rv;
+
+    MOZ_ASSERT(aAllowWrapping || !xpc::WrapperFactory::IsXrayWrapper(&aVal.toObject()),
+               "Shouldn't be returning a xray wrapper here");
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::WrapNative(JSContext * aJSContext,
+                        JSObject * aScopeArg,
+                        nsISupports* aCOMObj,
+                        const nsIID & aIID,
+                        JSObject** aRetVal)
+{
+    MOZ_ASSERT(aJSContext, "bad param");
+    MOZ_ASSERT(aScopeArg, "bad param");
+    MOZ_ASSERT(aCOMObj, "bad param");
+
+    RootedObject aScope(aJSContext, aScopeArg);
+    RootedValue v(aJSContext);
+    nsresult rv = NativeInterface2JSObject(aScope, aCOMObj, nullptr, &aIID,
+                                           true, &v, nullptr);
+    if (NS_FAILED(rv))
+        return rv;
+
+    if (!v.isObjectOrNull())
+        return NS_ERROR_FAILURE;
+
+    *aRetVal = v.toObjectOrNull();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::WrapNativeHolder(JSContext * aJSContext,
+                              JSObject * aScopeArg,
+                              nsISupports* aCOMObj,
+                              const nsIID & aIID,
+                              nsIXPConnectJSObjectHolder **aHolder)
+{
+    MOZ_ASSERT(aHolder, "bad param");
+    MOZ_ASSERT(aJSContext, "bad param");
+    MOZ_ASSERT(aScopeArg, "bad param");
+    MOZ_ASSERT(aCOMObj, "bad param");
+
+    RootedObject aScope(aJSContext, aScopeArg);
+    RootedValue v(aJSContext);
+    return NativeInterface2JSObject(aScope, aCOMObj, nullptr, &aIID,
+                                    true, &v, aHolder);
+}
+
+NS_IMETHODIMP
+nsXPConnect::WrapNativeToJSVal(JSContext* aJSContext,
+                               JSObject* aScopeArg,
+                               nsISupports* aCOMObj,
+                               nsWrapperCache* aCache,
+                               const nsIID* aIID,
+                               bool aAllowWrapping,
+                               MutableHandleValue aVal)
+{
+    MOZ_ASSERT(aJSContext, "bad param");
+    MOZ_ASSERT(aScopeArg, "bad param");
+    MOZ_ASSERT(aCOMObj, "bad param");
+
+    RootedObject aScope(aJSContext, aScopeArg);
+    return NativeInterface2JSObject(aScope, aCOMObj, aCache, aIID,
+                                    aAllowWrapping, aVal, nullptr);
+}
+
+NS_IMETHODIMP
+nsXPConnect::WrapJS(JSContext * aJSContext,
+                    JSObject * aJSObjArg,
+                    const nsIID & aIID,
+                    void * *result)
+{
+    MOZ_ASSERT(aJSContext, "bad param");
+    MOZ_ASSERT(aJSObjArg, "bad param");
+    MOZ_ASSERT(result, "bad param");
+
+    *result = nullptr;
+
+    RootedObject aJSObj(aJSContext, aJSObjArg);
+    JSAutoCompartment ac(aJSContext, aJSObj);
+
+    nsresult rv = NS_ERROR_UNEXPECTED;
+    if (!XPCConvert::JSObject2NativeInterface(result, aJSObj,
+                                              &aIID, nullptr, &rv))
+        return rv;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::JSValToVariant(JSContext* cx,
+                            HandleValue aJSVal,
+                            nsIVariant** aResult)
+{
+    NS_PRECONDITION(aResult, "bad param");
+
+    RefPtr<XPCVariant> variant = XPCVariant::newVariant(cx, aJSVal);
+    variant.forget(aResult);
+    NS_ENSURE_TRUE(*aResult, NS_ERROR_OUT_OF_MEMORY);
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::WrapJSAggregatedToNative(nsISupports* aOuter,
+                                      JSContext* aJSContext,
+                                      JSObject* aJSObjArg,
+                                      const nsIID& aIID,
+                                      void** result)
+{
+    MOZ_ASSERT(aOuter, "bad param");
+    MOZ_ASSERT(aJSContext, "bad param");
+    MOZ_ASSERT(aJSObjArg, "bad param");
+    MOZ_ASSERT(result, "bad param");
+
+    *result = nullptr;
+
+    RootedObject aJSObj(aJSContext, aJSObjArg);
+    nsresult rv;
+    if (!XPCConvert::JSObject2NativeInterface(result, aJSObj,
+                                              &aIID, aOuter, &rv))
+        return rv;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::GetWrappedNativeOfJSObject(JSContext * aJSContext,
+                                        JSObject * aJSObjArg,
+                                        nsIXPConnectWrappedNative** _retval)
+{
+    MOZ_ASSERT(aJSContext, "bad param");
+    MOZ_ASSERT(aJSObjArg, "bad param");
+    MOZ_ASSERT(_retval, "bad param");
+
+    RootedObject aJSObj(aJSContext, aJSObjArg);
+    aJSObj = js::CheckedUnwrap(aJSObj, /* stopAtWindowProxy = */ false);
+    if (!aJSObj || !IS_WN_REFLECTOR(aJSObj)) {
+        *_retval = nullptr;
+        return NS_ERROR_FAILURE;
+    }
+
+    RefPtr<XPCWrappedNative> temp = XPCWrappedNative::Get(aJSObj);
+    temp.forget(_retval);
+    return NS_OK;
+}
+
+already_AddRefed<nsISupports>
+xpc::UnwrapReflectorToISupports(JSObject* reflector)
+{
+    // Unwrap security wrappers, if allowed.
+    reflector = js::CheckedUnwrap(reflector, /* stopAtWindowProxy = */ false);
+    if (!reflector)
+        return nullptr;
+
+    // Try XPCWrappedNatives.
+    if (IS_WN_REFLECTOR(reflector)) {
+        XPCWrappedNative* wn = XPCWrappedNative::Get(reflector);
+        if (!wn)
+            return nullptr;
+        nsCOMPtr<nsISupports> native = wn->Native();
+        return native.forget();
+    }
+
+    // Try DOM objects.  This QI without taking a ref first is safe, because
+    // this if non-null our thing will definitely be a DOM object, and we know
+    // their QI to nsISupports doesn't do anything weird.
+    nsCOMPtr<nsISupports> canonical =
+        do_QueryInterface(mozilla::dom::UnwrapDOMObjectToISupports(reflector));
+    return canonical.forget();
+}
+
+NS_IMETHODIMP
+nsXPConnect::GetWrappedNativeOfNativeObject(JSContext * aJSContext,
+                                            JSObject * aScopeArg,
+                                            nsISupports* aCOMObj,
+                                            const nsIID & aIID,
+                                            nsIXPConnectWrappedNative** _retval)
+{
+    MOZ_ASSERT(aJSContext, "bad param");
+    MOZ_ASSERT(aScopeArg, "bad param");
+    MOZ_ASSERT(aCOMObj, "bad param");
+    MOZ_ASSERT(_retval, "bad param");
+
+    *_retval = nullptr;
+
+    RootedObject aScope(aJSContext, aScopeArg);
+
+    XPCWrappedNativeScope* scope = ObjectScope(aScope);
+    if (!scope)
+        return UnexpectedFailure(NS_ERROR_FAILURE);
+
+    RefPtr<XPCNativeInterface> iface =
+        XPCNativeInterface::GetNewOrUsed(&aIID);
+    if (!iface)
+        return NS_ERROR_FAILURE;
+
+    XPCWrappedNative* wrapper;
+
+    nsresult rv = XPCWrappedNative::GetUsedOnly(aCOMObj, scope, iface, &wrapper);
+    if (NS_FAILED(rv))
+        return NS_ERROR_FAILURE;
+    *_retval = static_cast<nsIXPConnectWrappedNative*>(wrapper);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::GetCurrentJSStack(nsIStackFrame * *aCurrentJSStack)
+{
+    MOZ_ASSERT(aCurrentJSStack, "bad param");
+
+    nsCOMPtr<nsIStackFrame> currentStack = dom::GetCurrentJSStack();
+    currentStack.forget(aCurrentJSStack);
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::GetCurrentNativeCallContext(nsAXPCNativeCallContext * *aCurrentNativeCallContext)
+{
+    MOZ_ASSERT(aCurrentNativeCallContext, "bad param");
+
+    *aCurrentNativeCallContext = XPCJSContext::Get()->GetCallContext();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::SetFunctionThisTranslator(const nsIID & aIID,
+                                       nsIXPCFunctionThisTranslator* aTranslator)
+{
+    XPCJSContext* cx = GetContext();
+    IID2ThisTranslatorMap* map = cx->GetThisTranslatorMap();
+    map->Add(aIID, aTranslator);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::CreateSandbox(JSContext* cx, nsIPrincipal* principal,
+                           JSObject** _retval)
+{
+    *_retval = nullptr;
+
+    RootedValue rval(cx);
+    SandboxOptions options;
+    nsresult rv = CreateSandboxObject(cx, &rval, principal, options);
+    MOZ_ASSERT(NS_FAILED(rv) || !rval.isPrimitive(),
+               "Bad return value from xpc_CreateSandboxObject()!");
+
+    if (NS_SUCCEEDED(rv) && !rval.isPrimitive()) {
+        *_retval = rval.toObjectOrNull();
+    }
+
+    return rv;
+}
+
+NS_IMETHODIMP
+nsXPConnect::EvalInSandboxObject(const nsAString& source, const char* filename,
+                                 JSContext* cx, JSObject* sandboxArg,
+                                 int32_t jsVersion,
+                                 MutableHandleValue rval)
+{
+#ifdef DEBUG
+    {
+        const char *version = JS_VersionToString(JSVersion(jsVersion));
+        MOZ_ASSERT(version && strcmp(version, "unknown") != 0, "Illegal JS version passed");
+    }
+#endif
+    if (!sandboxArg)
+        return NS_ERROR_INVALID_ARG;
+
+    RootedObject sandbox(cx, sandboxArg);
+    nsCString filenameStr;
+    if (filename) {
+        filenameStr.Assign(filename);
+    } else {
+        filenameStr = NS_LITERAL_CSTRING("x-bogus://XPConnect/Sandbox");
+    }
+    return EvalInSandbox(cx, sandbox, source, filenameStr, 1,
+                         JSVersion(jsVersion), rval);
+}
+
+NS_IMETHODIMP
+nsXPConnect::GetWrappedNativePrototype(JSContext* aJSContext,
+                                       JSObject* aScopeArg,
+                                       nsIClassInfo* aClassInfo,
+                                       JSObject** aRetVal)
+{
+    RootedObject aScope(aJSContext, aScopeArg);
+    JSAutoCompartment ac(aJSContext, aScope);
+
+    XPCWrappedNativeScope* scope = ObjectScope(aScope);
+    if (!scope)
+        return UnexpectedFailure(NS_ERROR_FAILURE);
+
+    XPCNativeScriptableCreateInfo sciProto;
+    XPCWrappedNative::GatherProtoScriptableCreateInfo(aClassInfo, sciProto);
+
+    AutoMarkingWrappedNativeProtoPtr proto(aJSContext);
+    proto = XPCWrappedNativeProto::GetNewOrUsed(scope, aClassInfo, &sciProto);
+    if (!proto)
+        return UnexpectedFailure(NS_ERROR_FAILURE);
+
+    JSObject* protoObj = proto->GetJSProtoObject();
+    if (!protoObj)
+        return UnexpectedFailure(NS_ERROR_FAILURE);
+
+    *aRetVal = protoObj;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::DebugDump(int16_t depth)
+{
+#ifdef DEBUG
+    depth-- ;
+    XPC_LOG_ALWAYS(("nsXPConnect @ %x with mRefCnt = %d", this, mRefCnt.get()));
+    XPC_LOG_INDENT();
+        XPC_LOG_ALWAYS(("gSelf @ %x", gSelf));
+        XPC_LOG_ALWAYS(("gOnceAliveNowDead is %d", (int)gOnceAliveNowDead));
+        if (mContext) {
+            if (depth)
+                mContext->DebugDump(depth);
+            else
+                XPC_LOG_ALWAYS(("XPCJSContext @ %x", mContext));
+        } else
+            XPC_LOG_ALWAYS(("mContext is null"));
+        XPCWrappedNativeScope::DebugDumpAllScopes(depth);
+    XPC_LOG_OUTDENT();
+#endif
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::DebugDumpObject(nsISupports* p, int16_t depth)
+{
+#ifdef DEBUG
+    if (!depth)
+        return NS_OK;
+    if (!p) {
+        XPC_LOG_ALWAYS(("*** Cound not dump object with NULL address"));
+        return NS_OK;
+    }
+
+    nsCOMPtr<nsIXPConnect> xpc;
+    nsCOMPtr<nsIXPCWrappedJSClass> wjsc;
+    nsCOMPtr<nsIXPConnectWrappedNative> wn;
+    nsCOMPtr<nsIXPConnectWrappedJS> wjs;
+
+    if (NS_SUCCEEDED(p->QueryInterface(NS_GET_IID(nsIXPConnect),
+                                       getter_AddRefs(xpc)))) {
+        XPC_LOG_ALWAYS(("Dumping a nsIXPConnect..."));
+        xpc->DebugDump(depth);
+    } else if (NS_SUCCEEDED(p->QueryInterface(NS_GET_IID(nsIXPCWrappedJSClass),
+                                              getter_AddRefs(wjsc)))) {
+        XPC_LOG_ALWAYS(("Dumping a nsIXPCWrappedJSClass..."));
+        wjsc->DebugDump(depth);
+    } else if (NS_SUCCEEDED(p->QueryInterface(NS_GET_IID(nsIXPConnectWrappedNative),
+                                              getter_AddRefs(wn)))) {
+        XPC_LOG_ALWAYS(("Dumping a nsIXPConnectWrappedNative..."));
+        wn->DebugDump(depth);
+    } else if (NS_SUCCEEDED(p->QueryInterface(NS_GET_IID(nsIXPConnectWrappedJS),
+                                              getter_AddRefs(wjs)))) {
+        XPC_LOG_ALWAYS(("Dumping a nsIXPConnectWrappedJS..."));
+        wjs->DebugDump(depth);
+    } else {
+        XPC_LOG_ALWAYS(("*** Could not dump the nsISupports @ %x", p));
+    }
+#endif
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::DebugDumpJSStack(bool showArgs,
+                              bool showLocals,
+                              bool showThisProps)
+{
+    xpc_DumpJSStack(showArgs, showLocals, showThisProps);
+
+    return NS_OK;
+}
+
+char*
+nsXPConnect::DebugPrintJSStack(bool showArgs,
+                               bool showLocals,
+                               bool showThisProps)
+{
+    JSContext* cx = nsContentUtils::GetCurrentJSContext();
+    if (!cx)
+        printf("there is no JSContext on the nsIThreadJSContextStack!\n");
+    else
+        return xpc_PrintJSStack(cx, showArgs, showLocals, showThisProps);
+
+    return nullptr;
+}
+
+NS_IMETHODIMP
+nsXPConnect::VariantToJS(JSContext* ctx, JSObject* scopeArg, nsIVariant* value,
+                         MutableHandleValue _retval)
+{
+    NS_PRECONDITION(ctx, "bad param");
+    NS_PRECONDITION(scopeArg, "bad param");
+    NS_PRECONDITION(value, "bad param");
+
+    RootedObject scope(ctx, scopeArg);
+    MOZ_ASSERT(js::IsObjectInContextCompartment(scope, ctx));
+
+    nsresult rv = NS_OK;
+    if (!XPCVariant::VariantDataToJS(value, &rv, _retval)) {
+        if (NS_FAILED(rv))
+            return rv;
+
+        return NS_ERROR_FAILURE;
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsXPConnect::JSToVariant(JSContext* ctx, HandleValue value, nsIVariant** _retval)
+{
+    NS_PRECONDITION(ctx, "bad param");
+    NS_PRECONDITION(_retval, "bad param");
+
+    RefPtr<XPCVariant> variant = XPCVariant::newVariant(ctx, value);
+    variant.forget(_retval);
+    if (!(*_retval))
+        return NS_ERROR_FAILURE;
+
+    return NS_OK;
+}
+
+nsIPrincipal*
+nsXPConnect::GetPrincipal(JSObject* obj, bool allowShortCircuit) const
+{
+    MOZ_ASSERT(IS_WN_REFLECTOR(obj), "What kind of wrapper is this?");
+
+    XPCWrappedNative* xpcWrapper = XPCWrappedNative::Get(obj);
+    if (xpcWrapper) {
+        if (allowShortCircuit) {
+            nsIPrincipal* result = xpcWrapper->GetObjectPrincipal();
+            if (result) {
+                return result;
+            }
+        }
+
+        // If not, check if it points to an nsIScriptObjectPrincipal
+        nsCOMPtr<nsIScriptObjectPrincipal> objPrin =
+            do_QueryInterface(xpcWrapper->Native());
+        if (objPrin) {
+            nsIPrincipal* result = objPrin->GetPrincipal();
+            if (result) {
+                return result;
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+namespace xpc {
+
+bool
+Base64Encode(JSContext* cx, HandleValue val, MutableHandleValue out)
+{
+    MOZ_ASSERT(cx);
+
+    nsAutoCString encodedString;
+    if (!ConvertJSValueToByteString(cx, val, false, encodedString)) {
+        return false;
+    }
+
+    nsAutoCString result;
+    if (NS_FAILED(mozilla::Base64Encode(encodedString, result))) {
+        JS_ReportErrorASCII(cx, "Failed to encode base64 data!");
+        return false;
+    }
+
+    JSString* str = JS_NewStringCopyN(cx, result.get(), result.Length());
+    if (!str)
+        return false;
+
+    out.setString(str);
+    return true;
+}
+
+bool
+Base64Decode(JSContext* cx, HandleValue val, MutableHandleValue out)
+{
+    MOZ_ASSERT(cx);
+
+    nsAutoCString encodedString;
+    if (!ConvertJSValueToByteString(cx, val, false, encodedString)) {
+        return false;
+    }
+
+    nsAutoCString result;
+    if (NS_FAILED(mozilla::Base64Decode(encodedString, result))) {
+        JS_ReportErrorASCII(cx, "Failed to decode base64 string!");
+        return false;
+    }
+
+    JSString* str = JS_NewStringCopyN(cx, result.get(), result.Length());
+    if (!str)
+        return false;
+
+    out.setString(str);
+    return true;
+}
+
+void
+SetLocationForGlobal(JSObject* global, const nsACString& location)
+{
+    MOZ_ASSERT(global);
+    CompartmentPrivate::Get(global)->SetLocation(location);
+}
+
+void
+SetLocationForGlobal(JSObject* global, nsIURI* locationURI)
+{
+    MOZ_ASSERT(global);
+    CompartmentPrivate::Get(global)->SetLocationURI(locationURI);
+}
+
+} // namespace xpc
+
+NS_IMETHODIMP
+nsXPConnect::NotifyDidPaint()
+{
+    JS::NotifyDidPaint(GetContext()->Context());
+    return NS_OK;
+}
+
+static nsresult
+WriteScriptOrFunction(nsIObjectOutputStream* stream, JSContext* cx,
+                      JSScript* scriptArg, HandleObject functionObj)
+{
+    // Exactly one of script or functionObj must be given
+    MOZ_ASSERT(!scriptArg != !functionObj);
+
+    RootedScript script(cx, scriptArg);
+    if (!script) {
+        RootedFunction fun(cx, JS_GetObjectFunction(functionObj));
+        script.set(JS_GetFunctionScript(cx, fun));
+    }
+
+    uint8_t flags = 0; // We don't have flags anymore.
+    nsresult rv = stream->Write8(flags);
+    if (NS_FAILED(rv))
+        return rv;
+
+
+    TranscodeBuffer buffer;
+    TranscodeResult code;
+    {
+        if (functionObj)
+            code = EncodeInterpretedFunction(cx, buffer, functionObj);
+        else
+            code = EncodeScript(cx, buffer, script);
+    }
+
+    if (code != TranscodeResult_Ok) {
+        if ((code & TranscodeResult_Failure) != 0)
+            return NS_ERROR_FAILURE;
+        MOZ_ASSERT((code & TranscodeResult_Throw) != 0);
+        JS_ClearPendingException(cx);
+        return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    size_t size = buffer.length();
+    if (size > UINT32_MAX)
+        return NS_ERROR_FAILURE;
+    rv = stream->Write32(size);
+    if (NS_SUCCEEDED(rv))
+        rv = stream->WriteBytes(reinterpret_cast<char*>(buffer.begin()), size);
+
+    return rv;
+}
+
+static nsresult
+ReadScriptOrFunction(nsIObjectInputStream* stream, JSContext* cx,
+                     JSScript** scriptp, JSObject** functionObjp)
+{
+    // Exactly one of script or functionObj must be given
+    MOZ_ASSERT(!scriptp != !functionObjp);
+
+    uint8_t flags;
+    nsresult rv = stream->Read8(&flags);
+    if (NS_FAILED(rv))
+        return rv;
+
+    // We don't serialize mutedError-ness of scripts, which is fine as long as
+    // we only serialize system and XUL-y things. We can detect this by checking
+    // where the caller wants us to deserialize.
+    MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome() ||
+                       CurrentGlobalOrNull(cx) == xpc::CompilationScope());
+
+    uint32_t size;
+    rv = stream->Read32(&size);
+    if (NS_FAILED(rv))
+        return rv;
+
+    char* data;
+    rv = stream->ReadBytes(size, &data);
+    if (NS_FAILED(rv))
+        return rv;
+
+    TranscodeBuffer buffer;
+    buffer.replaceRawBuffer(reinterpret_cast<uint8_t*>(data), size);
+
+    {
+        TranscodeResult code;
+        if (scriptp) {
+            Rooted<JSScript*> script(cx);
+            code = DecodeScript(cx, buffer, &script);
+            if (code == TranscodeResult_Ok)
+                *scriptp = script.get();
+        } else {
+            Rooted<JSFunction*> funobj(cx);
+            code = DecodeInterpretedFunction(cx, buffer, &funobj);
+            if (code == TranscodeResult_Ok)
+                *functionObjp = JS_GetFunctionObject(funobj.get());
+        }
+
+        if (code != TranscodeResult_Ok) {
+            if ((code & TranscodeResult_Failure) != 0)
+                return NS_ERROR_FAILURE;
+            MOZ_ASSERT((code & TranscodeResult_Throw) != 0);
+            JS_ClearPendingException(cx);
+            return NS_ERROR_OUT_OF_MEMORY;
+        }
+    }
+
+    return rv;
+}
+
+NS_IMETHODIMP
+nsXPConnect::WriteScript(nsIObjectOutputStream* stream, JSContext* cx, JSScript* script)
+{
+    return WriteScriptOrFunction(stream, cx, script, nullptr);
+}
+
+NS_IMETHODIMP
+nsXPConnect::ReadScript(nsIObjectInputStream* stream, JSContext* cx, JSScript** scriptp)
+{
+    return ReadScriptOrFunction(stream, cx, scriptp, nullptr);
+}
+
+NS_IMETHODIMP
+nsXPConnect::WriteFunction(nsIObjectOutputStream* stream, JSContext* cx, JSObject* functionObjArg)
+{
+    RootedObject functionObj(cx, functionObjArg);
+    return WriteScriptOrFunction(stream, cx, nullptr, functionObj);
+}
+
+NS_IMETHODIMP
+nsXPConnect::ReadFunction(nsIObjectInputStream* stream, JSContext* cx, JSObject** functionObjp)
+{
+    return ReadScriptOrFunction(stream, cx, nullptr, functionObjp);
+}
+
+/* These are here to be callable from a debugger */
+extern "C" {
+JS_EXPORT_API(void) DumpJSStack()
+{
+    xpc_DumpJSStack(true, true, false);
+}
+
+JS_EXPORT_API(char*) PrintJSStack()
+{
+    nsresult rv;
+    nsCOMPtr<nsIXPConnect> xpc(do_GetService(nsIXPConnect::GetCID(), &rv));
+    return (NS_SUCCEEDED(rv) && xpc) ?
+        xpc->DebugPrintJSStack(true, true, false) :
+        nullptr;
+}
+
+JS_EXPORT_API(void) DumpCompleteHeap()
+{
+    nsCOMPtr<nsICycleCollectorListener> listener =
+      do_CreateInstance("@mozilla.org/cycle-collector-logger;1");
+    if (!listener) {
+      NS_WARNING("Failed to create CC logger");
+      return;
+    }
+
+    nsCOMPtr<nsICycleCollectorListener> alltracesListener;
+    listener->AllTraces(getter_AddRefs(alltracesListener));
+    if (!alltracesListener) {
+      NS_WARNING("Failed to get all traces logger");
+      return;
+    }
+
+    nsJSContext::CycleCollectNow(alltracesListener);
+}
+
+} // extern "C"
+
+namespace xpc {
+
+bool
+Atob(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (!args.length())
+        return true;
+
+    return xpc::Base64Decode(cx, args[0], args.rval());
+}
+
+bool
+Btoa(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (!args.length())
+        return true;
+
+    return xpc::Base64Encode(cx, args[0], args.rval());
+}
+
+bool
+IsXrayWrapper(JSObject* obj)
+{
+    return WrapperFactory::IsXrayWrapper(obj);
+}
+
+JSAddonId*
+NewAddonId(JSContext* cx, const nsACString& id)
+{
+    JS::RootedString str(cx, JS_NewStringCopyN(cx, id.BeginReading(), id.Length()));
+    if (!str)
+        return nullptr;
+    return JS::NewAddonId(cx, str);
+}
+
+bool
+SetAddonInterposition(const nsACString& addonIdStr, nsIAddonInterposition* interposition)
+{
+    JSAddonId* addonId;
+    // We enter the junk scope just to allocate a string, which actually will go
+    // in the system zone.
+    AutoJSAPI jsapi;
+    if (!jsapi.Init(xpc::PrivilegedJunkScope()))
+        return false;
+    addonId = NewAddonId(jsapi.cx(), addonIdStr);
+    if (!addonId)
+        return false;
+    return XPCWrappedNativeScope::SetAddonInterposition(jsapi.cx(), addonId, interposition);
+}
+
+bool
+AllowCPOWsInAddon(const nsACString& addonIdStr, bool allow)
+{
+    JSAddonId* addonId;
+    // We enter the junk scope just to allocate a string, which actually will go
+    // in the system zone.
+    AutoJSAPI jsapi;
+    if (!jsapi.Init(xpc::PrivilegedJunkScope()))
+        return false;
+    addonId = NewAddonId(jsapi.cx(), addonIdStr);
+    if (!addonId)
+        return false;
+    return XPCWrappedNativeScope::AllowCPOWsInAddon(jsapi.cx(), addonId, allow);
+}
+
+} // namespace xpc
+
+namespace mozilla {
+namespace dom {
+
+bool
+IsChromeOrXBL(JSContext* cx, JSObject* /* unused */)
+{
+    MOZ_ASSERT(NS_IsMainThread());
+    JSCompartment* c = js::GetContextCompartment(cx);
+
+    // For remote XUL, we run XBL in the XUL scope. Given that we care about
+    // compat and not security for remote XUL, we just always claim to be XBL.
+    //
+    // Note that, for performance, we don't check AllowXULXBLForPrincipal here,
+    // and instead rely on the fact that AllowContentXBLScope() only returns false in
+    // remote XUL situations.
+    return AccessCheck::isChrome(c) || IsContentXBLScope(c) || !AllowContentXBLScope(c);
+}
+
+namespace workers {
+extern bool IsCurrentThreadRunningChromeWorker();
+} // namespace workers
+
+bool
+ThreadSafeIsChromeOrXBL(JSContext* cx, JSObject* obj)
+{
+    if (NS_IsMainThread()) {
+        return IsChromeOrXBL(cx, obj);
+    }
+    return workers::IsCurrentThreadRunningChromeWorker();
+}
+
+} // namespace dom
+} // namespace mozilla
diff --git a/js/xpconnect/src/qsObjectHelper.h b/js/xpconnect/src/qsObjectHelper.h
new file mode 100644
index 000000000..a3c753800
--- /dev/null
+++ b/js/xpconnect/src/qsObjectHelper.h
@@ -0,0 +1,53 @@
+/* -*- 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/. */
+
+#ifndef qsObjectHelper_h
+#define qsObjectHelper_h
+
+#include "xpcObjectHelper.h"
+
+#include "nsCOMPtr.h"
+#include "nsWrapperCache.h"
+#include "mozilla/TypeTraits.h"
+
+class qsObjectHelper : public xpcObjectHelper
+{
+public:
+    template <class T>
+    inline
+    qsObjectHelper(T* aObject, nsWrapperCache* aCache)
+        : xpcObjectHelper(ToSupports(aObject), ToCanonicalSupports(aObject),
+                          aCache)
+    {}
+
+    template <class T>
+    inline
+    qsObjectHelper(nsCOMPtr<T>& aObject, nsWrapperCache* aCache)
+        : xpcObjectHelper(ToSupports(aObject.get()),
+                          ToCanonicalSupports(aObject.get()), aCache)
+    {
+        if (mCanonical) {
+            // Transfer the strong reference.
+            mCanonicalStrong = dont_AddRef(mCanonical);
+            aObject.forget();
+        }
+    }
+
+    template <class T>
+    inline
+    qsObjectHelper(RefPtr<T>& aObject, nsWrapperCache* aCache)
+        : xpcObjectHelper(ToSupports(aObject.get()),
+                          ToCanonicalSupports(aObject.get()), aCache)
+    {
+        if (mCanonical) {
+            // Transfer the strong reference.
+            mCanonicalStrong = dont_AddRef(mCanonical);
+            aObject.forget();
+        }
+    }
+};
+
+#endif
diff --git a/js/xpconnect/src/xpc.msg b/js/xpconnect/src/xpc.msg
new file mode 100644
index 000000000..182cdbba8
--- /dev/null
+++ b/js/xpconnect/src/xpc.msg
@@ -0,0 +1,228 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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/. */
+
+/* Error Message definitions. */
+
+
+/* xpconnect specific codes (from nsIXPConnect.h) */
+
+XPC_MSG_DEF(NS_ERROR_XPC_NOT_ENOUGH_ARGS                , "Not enough arguments")
+XPC_MSG_DEF(NS_ERROR_XPC_NEED_OUT_OBJECT                , "'Out' argument must be an object")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_SET_OUT_VAL               , "Cannot set 'value' property of 'out' argument")
+XPC_MSG_DEF(NS_ERROR_XPC_NATIVE_RETURNED_FAILURE        , "Component returned failure code:")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_INTERFACE_INFO        , "Cannot find interface information")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_PARAM_IFACE_INFO      , "Cannot find interface information for parameter")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_METHOD_INFO           , "Cannot find method information")
+XPC_MSG_DEF(NS_ERROR_XPC_UNEXPECTED                     , "Unexpected error in XPConnect")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CONVERT_JS                 , "Could not convert JavaScript argument")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CONVERT_NATIVE             , "Could not convert Native argument")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CONVERT_JS_NULL_REF        , "Could not convert JavaScript argument (NULL value cannot be used for a C++ reference type)")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO             , "Illegal operation on WrappedNative prototype object")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CONVERT_WN_TO_FUN         , "Cannot convert WrappedNative to function")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_DEFINE_PROP_ON_WN         , "Cannot define new property in a WrappedNative")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_WATCH_WN_STATIC           , "Cannot place watchpoints on WrappedNative object static properties")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_EXPORT_WN_STATIC          , "Cannot export a WrappedNative object's static properties")
+XPC_MSG_DEF(NS_ERROR_XPC_SCRIPTABLE_CALL_FAILED         , "nsIXPCScriptable::Call failed")
+XPC_MSG_DEF(NS_ERROR_XPC_SCRIPTABLE_CTOR_FAILED         , "nsIXPCScriptable::Construct failed")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CALL_WO_SCRIPTABLE        , "Cannot use wrapper as function unless it implements nsIXPCScriptable")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CTOR_WO_SCRIPTABLE        , "Cannot use wrapper as constructor unless it implements nsIXPCScriptable")
+XPC_MSG_DEF(NS_ERROR_XPC_CI_RETURNED_FAILURE            , "ComponentManager::CreateInstance returned failure code:")
+XPC_MSG_DEF(NS_ERROR_XPC_GS_RETURNED_FAILURE            , "ServiceManager::GetService returned failure code:")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CID                        , "Invalid ClassID or ContractID")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_IID                        , "Invalid InterfaceID")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CREATE_WN                 , "Cannot create wrapper around native interface")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_EXCEPTION             , "JavaScript component threw exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_NATIVE_OBJECT         , "JavaScript component threw a native object that is not an exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_JS_OBJECT             , "JavaScript component threw a JavaScript object")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_NULL                  , "JavaScript component threw a null value as an exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_STRING                , "JavaScript component threw a string as an exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JS_THREW_NUMBER                , "JavaScript component threw a number as an exception")
+XPC_MSG_DEF(NS_ERROR_XPC_JAVASCRIPT_ERROR               , "JavaScript component caused a JavaScript error")
+XPC_MSG_DEF(NS_ERROR_XPC_JAVASCRIPT_ERROR_WITH_DETAILS  , "JavaScript component caused a JavaScript error (detailed report attached)")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CONVERT_PRIMITIVE_TO_ARRAY, "Cannot convert primitive JavaScript value into an array")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_CONVERT_OBJECT_TO_ARRAY   , "Cannot convert JavaScript object into an array")
+XPC_MSG_DEF(NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY   , "JavaScript Array does not have as many elements as indicated by size argument")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_ARRAY_INFO            , "Cannot find array information")
+XPC_MSG_DEF(NS_ERROR_XPC_NOT_ENOUGH_CHARS_IN_STRING     , "JavaScript String does not have as many characters as indicated by size argument")
+XPC_MSG_DEF(NS_ERROR_XPC_SECURITY_MANAGER_VETO          , "Security Manager vetoed action")
+XPC_MSG_DEF(NS_ERROR_XPC_INTERFACE_NOT_SCRIPTABLE       , "Failed to build a wrapper because the interface that was not declared [scriptable]")
+XPC_MSG_DEF(NS_ERROR_XPC_INTERFACE_NOT_FROM_NSISUPPORTS , "Failed to build a wrapper because the interface does not inherit from nsISupports")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_GET_JSOBJECT_OF_DOM_OBJECT, "Cannot get JavaScript object for DOM object")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_SET_READ_ONLY_CONSTANT    , "Property is a constant and cannot be changed")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_SET_READ_ONLY_ATTRIBUTE   , "Property is a read only attribute and cannot be changed")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_SET_READ_ONLY_METHOD      , "Property is an interface method and cannot be changed")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_ADD_PROP_TO_WRAPPED_NATIVE, "Cannot add property to WrappedNative object")
+XPC_MSG_DEF(NS_ERROR_XPC_CALL_TO_SCRIPTABLE_FAILED      , "Call to nsIXPCScriptable interface for WrappedNative failed unexpecedly")
+XPC_MSG_DEF(NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED , "JavaScript component does not have a method named:")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_ID_STRING                  , "Bad ID string")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_INITIALIZER_NAME           , "Bad initializer name in Constructor - Component has no method with that name")
+XPC_MSG_DEF(NS_ERROR_XPC_HAS_BEEN_SHUTDOWN              , "Operation failed because the XPConnect subsystem has been shutdown")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_MODIFY_PROP_ON_WN         , "Cannot modify properties of a WrappedNative")
+XPC_MSG_DEF(NS_ERROR_XPC_BAD_CONVERT_JS_ZERO_ISNOT_NULL , "Could not convert JavaScript argument - 0 was passed, expected object. Did you mean null?")
+XPC_MSG_DEF(NS_ERROR_XPC_CANT_PASS_CPOW_TO_NATIVE       , "It's illegal to pass a CPOW to native code")
+
+
+/* common global codes (from nsError.h) */
+
+XPC_MSG_DEF(NS_OK                                  , "Success")
+XPC_MSG_DEF(NS_ERROR_NOT_INITIALIZED               , "Component not initialized")
+XPC_MSG_DEF(NS_ERROR_ALREADY_INITIALIZED           , "Component already initialized")
+XPC_MSG_DEF(NS_ERROR_NOT_IMPLEMENTED               , "Method not implemented")
+XPC_MSG_DEF(NS_NOINTERFACE                         , "Component does not have requested interface")
+XPC_MSG_DEF(NS_ERROR_NO_INTERFACE                  , "Component does not have requested interface")
+XPC_MSG_DEF(NS_ERROR_ILLEGAL_VALUE                 , "Illegal value")
+XPC_MSG_DEF(NS_ERROR_INVALID_POINTER               , "Invalid pointer")
+XPC_MSG_DEF(NS_ERROR_NULL_POINTER                  , "Null pointer")
+XPC_MSG_DEF(NS_ERROR_ABORT                         , "Abort")
+XPC_MSG_DEF(NS_ERROR_FAILURE                       , "Failure")
+XPC_MSG_DEF(NS_ERROR_UNEXPECTED                    , "Unexpected error")
+XPC_MSG_DEF(NS_ERROR_OUT_OF_MEMORY                 , "Out of Memory")
+XPC_MSG_DEF(NS_ERROR_INVALID_ARG                   , "Invalid argument")
+XPC_MSG_DEF(NS_ERROR_NO_AGGREGATION                , "Component does not support aggregation")
+XPC_MSG_DEF(NS_ERROR_NOT_AVAILABLE                 , "Component is not available")
+XPC_MSG_DEF(NS_ERROR_FACTORY_NOT_REGISTERED        , "Factory not registered")
+XPC_MSG_DEF(NS_ERROR_FACTORY_REGISTER_AGAIN        , "Factory not registered (may be tried again)")
+XPC_MSG_DEF(NS_ERROR_FACTORY_NOT_LOADED            , "Factory not loaded")
+XPC_MSG_DEF(NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT  , "Factory does not support signatures")
+XPC_MSG_DEF(NS_ERROR_FACTORY_EXISTS                , "Factory already exists")
+
+/* added from nsError.h on Feb 28 2001... */
+
+XPC_MSG_DEF(NS_BASE_STREAM_CLOSED                   , "Stream closed")
+XPC_MSG_DEF(NS_BASE_STREAM_OSERROR                  , "Error from the operating system")
+XPC_MSG_DEF(NS_BASE_STREAM_ILLEGAL_ARGS             , "Illegal arguments")
+XPC_MSG_DEF(NS_BASE_STREAM_NO_CONVERTER             , "No converter for unichar streams")
+XPC_MSG_DEF(NS_BASE_STREAM_BAD_CONVERSION           , "Bad converter for unichar streams")
+XPC_MSG_DEF(NS_BASE_STREAM_WOULD_BLOCK              , "Stream would block")
+
+XPC_MSG_DEF(NS_ERROR_FILE_UNRECOGNIZED_PATH         , "File error: Unrecognized path")
+XPC_MSG_DEF(NS_ERROR_FILE_UNRESOLVABLE_SYMLINK      , "File error: Unresolvable symlink")
+XPC_MSG_DEF(NS_ERROR_FILE_EXECUTION_FAILED          , "File error: Execution failed")
+XPC_MSG_DEF(NS_ERROR_FILE_UNKNOWN_TYPE              , "File error: Unknown type")
+XPC_MSG_DEF(NS_ERROR_FILE_DESTINATION_NOT_DIR       , "File error: Destination not dir")
+XPC_MSG_DEF(NS_ERROR_FILE_TARGET_DOES_NOT_EXIST     , "File error: Target does not exist")
+XPC_MSG_DEF(NS_ERROR_FILE_COPY_OR_MOVE_FAILED       , "File error: Copy or move failed")
+XPC_MSG_DEF(NS_ERROR_FILE_ALREADY_EXISTS            , "File error: Already exists")
+XPC_MSG_DEF(NS_ERROR_FILE_INVALID_PATH              , "File error: Invalid path")
+XPC_MSG_DEF(NS_ERROR_FILE_DISK_FULL                 , "File error: Disk full")
+XPC_MSG_DEF(NS_ERROR_FILE_CORRUPTED                 , "File error: Corrupted")
+XPC_MSG_DEF(NS_ERROR_FILE_NOT_DIRECTORY             , "File error: Not directory")
+XPC_MSG_DEF(NS_ERROR_FILE_IS_DIRECTORY              , "File error: Is directory")
+XPC_MSG_DEF(NS_ERROR_FILE_IS_LOCKED                 , "File error: Is locked")
+XPC_MSG_DEF(NS_ERROR_FILE_TOO_BIG                   , "File error: Too big")
+XPC_MSG_DEF(NS_ERROR_FILE_NO_DEVICE_SPACE           , "File error: No device space")
+XPC_MSG_DEF(NS_ERROR_FILE_NAME_TOO_LONG             , "File error: Name too long")
+XPC_MSG_DEF(NS_ERROR_FILE_NOT_FOUND                 , "File error: Not found")
+XPC_MSG_DEF(NS_ERROR_FILE_READ_ONLY                 , "File error: Read only")
+XPC_MSG_DEF(NS_ERROR_FILE_DIR_NOT_EMPTY             , "File error: Dir not empty")
+XPC_MSG_DEF(NS_ERROR_FILE_ACCESS_DENIED             , "File error: Access denied")
+
+/* added from nsError.h on Sept 6 2001... */
+
+XPC_MSG_DEF(NS_ERROR_CANNOT_CONVERT_DATA            , "Data conversion error")
+XPC_MSG_DEF(NS_ERROR_OBJECT_IS_IMMUTABLE            , "Can not modify immutable data container")
+XPC_MSG_DEF(NS_ERROR_LOSS_OF_SIGNIFICANT_DATA       , "Data conversion failed because significant data would be lost")
+XPC_MSG_DEF(NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA   , "Data conversion succeeded but data was rounded to fit")
+
+/* network related codes (from nsNetError.h) */
+
+XPC_MSG_DEF(NS_BINDING_FAILED                       , "The async request failed for some unknown reason")
+XPC_MSG_DEF(NS_BINDING_ABORTED                      , "The async request failed because it was aborted by some user action")
+XPC_MSG_DEF(NS_BINDING_REDIRECTED                   , "The async request has been redirected to a different async request")
+XPC_MSG_DEF(NS_BINDING_RETARGETED                   , "The async request has been retargeted to a different handler")
+XPC_MSG_DEF(NS_ERROR_MALFORMED_URI                  , "The URI is malformed")
+XPC_MSG_DEF(NS_ERROR_UNKNOWN_PROTOCOL               , "The URI scheme corresponds to an unknown protocol handler")
+XPC_MSG_DEF(NS_ERROR_NO_CONTENT                     , "Channel opened successfully but no data will be returned")
+XPC_MSG_DEF(NS_ERROR_IN_PROGRESS                    , "The requested action could not be completed while the object is busy")
+XPC_MSG_DEF(NS_ERROR_ALREADY_OPENED                 , "Channel is already open")
+XPC_MSG_DEF(NS_ERROR_INVALID_CONTENT_ENCODING       , "The content encoding of the source document is incorrect")
+XPC_MSG_DEF(NS_ERROR_CORRUPTED_CONTENT              , "Corrupted content received from server (potentially MIME type mismatch because of 'X-Content-Type-Options: nosniff')")
+XPC_MSG_DEF(NS_ERROR_FIRST_HEADER_FIELD_COMPONENT_EMPTY, "Couldn't extract first component from potentially corrupted header field")
+XPC_MSG_DEF(NS_ERROR_ALREADY_CONNECTED              , "The connection is already established")
+XPC_MSG_DEF(NS_ERROR_NOT_CONNECTED                  , "The connection does not exist")
+XPC_MSG_DEF(NS_ERROR_CONNECTION_REFUSED             , "The connection was refused")
+XPC_MSG_DEF(NS_ERROR_PROXY_CONNECTION_REFUSED       , "The connection to the proxy server was refused")
+XPC_MSG_DEF(NS_ERROR_NET_TIMEOUT                    , "The connection has timed out")
+XPC_MSG_DEF(NS_ERROR_OFFLINE                        , "The requested action could not be completed in the offline state")
+XPC_MSG_DEF(NS_ERROR_PORT_ACCESS_NOT_ALLOWED        , "Establishing a connection to an unsafe or otherwise banned port was prohibited")
+XPC_MSG_DEF(NS_ERROR_NET_RESET                      , "The connection was established, but no data was ever received")
+XPC_MSG_DEF(NS_ERROR_NET_INTERRUPT                  , "The connection was established, but the data transfer was interrupted")
+XPC_MSG_DEF(NS_ERROR_NET_PARTIAL_TRANSFER           , "A transfer was only partially done when it completed")
+XPC_MSG_DEF(NS_ERROR_NOT_RESUMABLE                  , "This request is not resumable, but it was tried to resume it, or to request resume-specific data")
+XPC_MSG_DEF(NS_ERROR_ENTITY_CHANGED                 , "It was attempted to resume the request, but the entity has changed in the meantime")
+XPC_MSG_DEF(NS_ERROR_REDIRECT_LOOP                  , "The request failed as a result of a detected redirection loop")
+XPC_MSG_DEF(NS_ERROR_UNSAFE_CONTENT_TYPE            , "The request failed because the content type returned by the server was not a type expected by the channel")
+XPC_MSG_DEF(NS_ERROR_REMOTE_XUL                     , "Attempt to access remote XUL document that is not in website's whitelist")
+XPC_MSG_DEF(NS_ERROR_LOAD_SHOWED_ERRORPAGE          , "The load caused an error page to be displayed.")
+
+XPC_MSG_DEF(NS_ERROR_FTP_LOGIN                      , "FTP error while logging in")
+XPC_MSG_DEF(NS_ERROR_FTP_CWD                        , "FTP error while changing directory")
+XPC_MSG_DEF(NS_ERROR_FTP_PASV                       , "FTP error while changing to passive mode")
+XPC_MSG_DEF(NS_ERROR_FTP_PWD                        , "FTP error while retrieving current directory")
+XPC_MSG_DEF(NS_ERROR_FTP_LIST                       , "FTP error while retrieving a directory listing")
+XPC_MSG_DEF(NS_ERROR_UNKNOWN_HOST                   , "The lookup of the hostname failed")
+XPC_MSG_DEF(NS_ERROR_DNS_LOOKUP_QUEUE_FULL          , "The DNS lookup queue is full")
+XPC_MSG_DEF(NS_ERROR_UNKNOWN_PROXY_HOST             , "The lookup of the proxy hostname failed")
+XPC_MSG_DEF(NS_ERROR_UNKNOWN_SOCKET_TYPE            , "The specified socket type does not exist")
+XPC_MSG_DEF(NS_ERROR_SOCKET_CREATE_FAILED           , "The specified socket type could not be created")
+XPC_MSG_DEF(NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED   , "The specified socket address type is not supported")
+XPC_MSG_DEF(NS_ERROR_SOCKET_ADDRESS_IN_USE          , "Some other socket is already using the specified address.")
+XPC_MSG_DEF(NS_ERROR_CACHE_KEY_NOT_FOUND            , "Cache key could not be found")
+XPC_MSG_DEF(NS_ERROR_CACHE_DATA_IS_STREAM           , "Cache data is a stream")
+XPC_MSG_DEF(NS_ERROR_CACHE_DATA_IS_NOT_STREAM       , "Cache data is not a stream")
+XPC_MSG_DEF(NS_ERROR_CACHE_WAIT_FOR_VALIDATION      , "Cache entry exists but needs to be validated first")
+XPC_MSG_DEF(NS_ERROR_CACHE_ENTRY_DOOMED             , "Cache entry has been  doomed")
+XPC_MSG_DEF(NS_ERROR_CACHE_READ_ACCESS_DENIED       , "Read access to cache denied")
+XPC_MSG_DEF(NS_ERROR_CACHE_WRITE_ACCESS_DENIED      , "Write access to cache denied")
+XPC_MSG_DEF(NS_ERROR_CACHE_IN_USE                   , "Cache is currently in use")
+XPC_MSG_DEF(NS_ERROR_DOCUMENT_NOT_CACHED            , "Document does not exist in cache")
+XPC_MSG_DEF(NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS     , "The requested number of domain levels exceeds those present in the host string")
+XPC_MSG_DEF(NS_ERROR_HOST_IS_IP_ADDRESS             , "The host string is an IP address")
+XPC_MSG_DEF(NS_ERROR_NOT_SAME_THREAD                , "Can't access a wrapped JS object from a different thread")
+
+/* storage related codes (from mozStorage.h) */
+XPC_MSG_DEF(NS_ERROR_STORAGE_BUSY                   , "SQLite database connection is busy")
+XPC_MSG_DEF(NS_ERROR_STORAGE_IOERR                  , "SQLite encountered an IO error")
+XPC_MSG_DEF(NS_ERROR_STORAGE_CONSTRAINT             , "SQLite database operation failed because a constraint was violated")
+
+/* plugin related codes (from nsPluginError.h) */
+XPC_MSG_DEF(NS_ERROR_PLUGIN_TIME_RANGE_NOT_SUPPORTED, "Clearing site data by time range not supported by plugin")
+
+/* character converter related codes (from nsIUnicodeDecoder.h) */
+XPC_MSG_DEF(NS_ERROR_ILLEGAL_INPUT                  , "The input characters have illegal sequences")
+
+/* Codes related to signd jars */
+XPC_MSG_DEF(NS_ERROR_SIGNED_JAR_NOT_SIGNED          , "The JAR is not signed.")
+XPC_MSG_DEF(NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY      , "An entry in the JAR has been modified after the JAR was signed.")
+XPC_MSG_DEF(NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY      , "An entry in the JAR has not been signed.")
+XPC_MSG_DEF(NS_ERROR_SIGNED_JAR_ENTRY_MISSING       , "An entry is missing from the JAR file.")
+XPC_MSG_DEF(NS_ERROR_SIGNED_JAR_WRONG_SIGNATURE     , "The JAR's signature is wrong.")
+XPC_MSG_DEF(NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE     , "An entry in the JAR is too large.")
+XPC_MSG_DEF(NS_ERROR_SIGNED_JAR_ENTRY_INVALID       , "An entry in the JAR is invalid.")
+XPC_MSG_DEF(NS_ERROR_SIGNED_JAR_MANIFEST_INVALID    , "The JAR's manifest or signature file is invalid.")
+
+/* Codes related to signed manifests */
+XPC_MSG_DEF(NS_ERROR_SIGNED_APP_MANIFEST_INVALID   , "The signed app manifest or signature file is invalid.")
+
+/* Codes for printing-related errors. */
+XPC_MSG_DEF(NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE , "No printers available.")
+XPC_MSG_DEF(NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND       , "The selected printer could not be found.")
+XPC_MSG_DEF(NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE  , "Failed to open output file for print to file.")
+XPC_MSG_DEF(NS_ERROR_GFX_PRINTER_STARTDOC             , "Printing failed while starting the print job.")
+XPC_MSG_DEF(NS_ERROR_GFX_PRINTER_ENDDOC               , "Printing failed while completing the print job.")
+XPC_MSG_DEF(NS_ERROR_GFX_PRINTER_STARTPAGE            , "Printing failed while starting a new page.")
+XPC_MSG_DEF(NS_ERROR_GFX_PRINTER_DOC_IS_BUSY          , "Cannot print this document yet, it is still being loaded.")
+
+/* Codes related to content */
+XPC_MSG_DEF(NS_ERROR_CONTENT_CRASHED                  , "The process that hosted this content has crashed.")
+
+/* Codes for the JS-implemented Push DOM API. These can be removed as part of bug 1252660. */
+XPC_MSG_DEF(NS_ERROR_DOM_PUSH_INVALID_KEY_ERR         , "Invalid raw ECDSA P-256 public key.")
+XPC_MSG_DEF(NS_ERROR_DOM_PUSH_MISMATCHED_KEY_ERR      , "A subscription with a different application server key already exists.")
+
+/* Codes defined in WebIDL https://heycam.github.io/webidl/#idl-DOMException-error-names */
+XPC_MSG_DEF(NS_ERROR_DOM_NOT_FOUND_ERR                , "The object can not be found here.")
+XPC_MSG_DEF(NS_ERROR_DOM_NOT_ALLOWED_ERR              , "The request is not allowed.")
diff --git a/js/xpconnect/src/xpcObjectHelper.h b/js/xpconnect/src/xpcObjectHelper.h
new file mode 100644
index 000000000..10090a901
--- /dev/null
+++ b/js/xpconnect/src/xpcObjectHelper.h
@@ -0,0 +1,137 @@
+/* -*- 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/. */
+
+#ifndef xpcObjectHelper_h
+#define xpcObjectHelper_h
+
+// Including 'windows.h' will #define GetClassInfo to something else.
+#ifdef XP_WIN
+#ifdef GetClassInfo
+#undef GetClassInfo
+#endif
+#endif
+
+#include "mozilla/Attributes.h"
+#include <stdint.h>
+#include "nsCOMPtr.h"
+#include "nsIClassInfo.h"
+#include "nsISupports.h"
+#include "nsIXPCScriptable.h"
+#include "nsWrapperCache.h"
+
+class xpcObjectHelper
+{
+public:
+    explicit xpcObjectHelper(nsISupports* aObject, nsWrapperCache* aCache = nullptr)
+      : mCanonical(nullptr)
+      , mObject(aObject)
+      , mCache(aCache)
+    {
+        if (!mCache) {
+            if (aObject)
+                CallQueryInterface(aObject, &mCache);
+            else
+                mCache = nullptr;
+        }
+    }
+
+    nsISupports* Object()
+    {
+        return mObject;
+    }
+
+    nsISupports* GetCanonical()
+    {
+        if (!mCanonical) {
+            mCanonicalStrong = do_QueryInterface(mObject);
+            mCanonical = mCanonicalStrong;
+        }
+        return mCanonical;
+    }
+
+    already_AddRefed<nsISupports> forgetCanonical()
+    {
+        MOZ_ASSERT(mCanonical, "Huh, no canonical to forget?");
+
+        if (!mCanonicalStrong)
+            mCanonicalStrong = mCanonical;
+        mCanonical = nullptr;
+        return mCanonicalStrong.forget();
+    }
+
+    nsIClassInfo* GetClassInfo()
+    {
+        if (mXPCClassInfo)
+          return mXPCClassInfo;
+        if (!mClassInfo)
+            mClassInfo = do_QueryInterface(mObject);
+        return mClassInfo;
+    }
+    nsXPCClassInfo* GetXPCClassInfo()
+    {
+        if (!mXPCClassInfo) {
+            CallQueryInterface(mObject, getter_AddRefs(mXPCClassInfo));
+        }
+        return mXPCClassInfo;
+    }
+
+    already_AddRefed<nsXPCClassInfo> forgetXPCClassInfo()
+    {
+        GetXPCClassInfo();
+
+        return mXPCClassInfo.forget();
+    }
+
+    // We assert that we can reach an nsIXPCScriptable somehow.
+    uint32_t GetScriptableFlags()
+    {
+        // Try getting an nsXPCClassInfo - this handles DOM scriptable helpers.
+        nsCOMPtr<nsIXPCScriptable> sinfo = GetXPCClassInfo();
+
+        // If that didn't work, try just QI-ing. This handles BackstagePass.
+        if (!sinfo)
+            sinfo = do_QueryInterface(GetCanonical());
+
+        // We should have something by now.
+        MOZ_ASSERT(sinfo);
+
+        // Grab the flags.
+        return sinfo->GetScriptableFlags();
+    }
+
+    nsWrapperCache* GetWrapperCache()
+    {
+        return mCache;
+    }
+
+protected:
+    xpcObjectHelper(nsISupports* aObject, nsISupports* aCanonical,
+                    nsWrapperCache* aCache)
+      : mCanonical(aCanonical)
+      , mObject(aObject)
+      , mCache(aCache)
+    {
+        if (!mCache && aObject)
+            CallQueryInterface(aObject, &mCache);
+    }
+
+    nsCOMPtr<nsISupports>    mCanonicalStrong;
+    nsISupports* MOZ_UNSAFE_REF("xpcObjectHelper has been specifically optimized "
+                                "to avoid unnecessary AddRefs and Releases. "
+                                "(see bug 565742)") mCanonical;
+
+private:
+    xpcObjectHelper(xpcObjectHelper& aOther) = delete;
+
+    nsISupports* MOZ_UNSAFE_REF("xpcObjectHelper has been specifically optimized "
+                                "to avoid unnecessary AddRefs and Releases. "
+                                "(see bug 565742)") mObject;
+    nsWrapperCache*          mCache;
+    nsCOMPtr<nsIClassInfo>   mClassInfo;
+    RefPtr<nsXPCClassInfo> mXPCClassInfo;
+};
+
+#endif
diff --git a/js/xpconnect/src/xpcprivate.h b/js/xpconnect/src/xpcprivate.h
new file mode 100644
index 000000000..d7d5586b8
--- /dev/null
+++ b/js/xpconnect/src/xpcprivate.h
@@ -0,0 +1,3426 @@
+/* -*- 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/. */
+
+/*
+ * XPConnect allows JS code to manipulate C++ object and C++ code to manipulate
+ * JS objects. JS manipulation of C++ objects tends to be significantly more
+ * complex. This comment explains how it is orchestrated by XPConnect.
+ *
+ * For each C++ object to be manipulated in JS, there is a corresponding JS
+ * object. This is called the "flattened JS object". By default, there is an
+ * additional C++ object involved of type XPCWrappedNative. The XPCWrappedNative
+ * holds pointers to the C++ object and the flat JS object.
+ *
+ * All XPCWrappedNative objects belong to an XPCWrappedNativeScope. These scopes
+ * are essentially in 1:1 correspondence with JS global objects. The
+ * XPCWrappedNativeScope has a pointer to the JS global object. The parent of a
+ * flattened JS object is, by default, the global JS object corresponding to the
+ * wrapper's XPCWrappedNativeScope (the exception to this rule is when a
+ * PreCreate hook asks for a different parent; see nsIXPCScriptable below).
+ *
+ * Some C++ objects (notably DOM objects) have information associated with them
+ * that lists the interfaces implemented by these objects. A C++ object exposes
+ * this information by implementing nsIClassInfo. If a C++ object implements
+ * nsIClassInfo, then JS code can call its methods without needing to use
+ * QueryInterface first. Typically, all instances of a C++ class share the same
+ * nsIClassInfo instance. (That is, obj->QueryInterface(nsIClassInfo) returns
+ * the same result for every obj of a given class.)
+ *
+ * XPConnect tracks nsIClassInfo information in an XPCWrappedNativeProto object.
+ * A given XPCWrappedNativeScope will have one XPCWrappedNativeProto for each
+ * nsIClassInfo instance being used. The XPCWrappedNativeProto has an associated
+ * JS object, which is used as the prototype of all flattened JS objects created
+ * for C++ objects with the given nsIClassInfo.
+ *
+ * Each XPCWrappedNativeProto has a pointer to its XPCWrappedNativeScope. If an
+ * XPCWrappedNative wraps a C++ object with class info, then it points to its
+ * XPCWrappedNativeProto. Otherwise it points to its XPCWrappedNativeScope. (The
+ * pointers are smooshed together in a tagged union.) Either way it can reach
+ * its scope.
+ *
+ * An XPCWrappedNativeProto keeps track of the set of interfaces implemented by
+ * the C++ object in an XPCNativeSet. (The list of interfaces is obtained by
+ * calling a method on the nsIClassInfo.) An XPCNativeSet is a collection of
+ * XPCNativeInterfaces. Each interface stores the list of members, which can be
+ * methods, constants, getters, or setters.
+ *
+ * An XPCWrappedNative also points to an XPCNativeSet. Initially this starts out
+ * the same as the XPCWrappedNativeProto's set. If there is no proto, it starts
+ * out as a singleton set containing nsISupports. If JS code QI's new interfaces
+ * outside of the existing set, the set will grow. All QueryInterface results
+ * are cached in XPCWrappedNativeTearOff objects, which are linked off of the
+ * XPCWrappedNative.
+ *
+ * Besides having class info, a C++ object may be "scriptable" (i.e., implement
+ * nsIXPCScriptable). This allows it to implement a more DOM-like interface,
+ * besides just exposing XPCOM methods and constants. An nsIXPCScriptable
+ * instance has hooks that correspond to all the normal JSClass hooks. Each
+ * nsIXPCScriptable instance is mirrored by an XPCNativeScriptableInfo in
+ * XPConnect. These can have pointers from XPCWrappedNativeProto and
+ * XPCWrappedNative (since C++ objects can have scriptable info without having
+ * class info).
+ */
+
+/* All the XPConnect private declarations - only include locally. */
+
+#ifndef xpcprivate_h___
+#define xpcprivate_h___
+
+#include "mozilla/Alignment.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/CycleCollectedJSContext.h"
+#include "mozilla/GuardObjects.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtr.h"
+
+#include "mozilla/dom/ScriptSettings.h"
+
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "xpcpublic.h"
+#include "js/TracingAPI.h"
+#include "js/WeakMapPtr.h"
+#include "PLDHashTable.h"
+#include "nscore.h"
+#include "nsXPCOM.h"
+#include "nsAutoPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsDebug.h"
+#include "nsISupports.h"
+#include "nsIServiceManager.h"
+#include "nsIClassInfoImpl.h"
+#include "nsIComponentManager.h"
+#include "nsIComponentRegistrar.h"
+#include "nsISupportsPrimitives.h"
+#include "nsMemory.h"
+#include "nsIXPConnect.h"
+#include "nsIInterfaceInfo.h"
+#include "nsIXPCScriptable.h"
+#include "nsIObserver.h"
+#include "nsWeakReference.h"
+#include "nsCOMPtr.h"
+#include "nsXPTCUtils.h"
+#include "xptinfo.h"
+#include "XPCForwards.h"
+#include "XPCLog.h"
+#include "xpccomponents.h"
+#include "xpcexception.h"
+#include "xpcjsid.h"
+#include "prenv.h"
+#include "prclist.h"
+#include "prcvar.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "nsXPIDLString.h"
+
+#include "MainThreadUtils.h"
+
+#include "nsIConsoleService.h"
+#include "nsIScriptError.h"
+#include "nsIException.h"
+
+#include "nsVariant.h"
+#include "nsIPropertyBag.h"
+#include "nsIProperty.h"
+#include "nsCOMArray.h"
+#include "nsTArray.h"
+#include "nsBaseHashtable.h"
+#include "nsHashKeys.h"
+#include "nsWrapperCache.h"
+#include "nsStringBuffer.h"
+#include "nsDataHashtable.h"
+#include "nsDeque.h"
+
+#include "nsIScriptSecurityManager.h"
+
+#include "nsIPrincipal.h"
+#include "nsJSPrincipals.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "xpcObjectHelper.h"
+
+#include "SandboxPrivate.h"
+#include "BackstagePass.h"
+#include "nsAXPCNativeCallContext.h"
+
+#ifdef XP_WIN
+// Nasty MS defines
+#ifdef GetClassInfo
+#undef GetClassInfo
+#endif
+#ifdef GetClassName
+#undef GetClassName
+#endif
+#endif /* XP_WIN */
+
+/***************************************************************************/
+// default initial sizes for maps (hashtables)
+
+#define XPC_JS_MAP_LENGTH                       32
+#define XPC_JS_CLASS_MAP_LENGTH                 32
+
+#define XPC_NATIVE_MAP_LENGTH                    8
+#define XPC_NATIVE_PROTO_MAP_LENGTH              8
+#define XPC_DYING_NATIVE_PROTO_MAP_LENGTH        8
+#define XPC_NATIVE_INTERFACE_MAP_LENGTH         32
+#define XPC_NATIVE_SET_MAP_LENGTH               32
+#define XPC_THIS_TRANSLATOR_MAP_LENGTH           4
+#define XPC_WRAPPER_MAP_LENGTH                   8
+
+/***************************************************************************/
+// data declarations...
+extern const char XPC_CONTEXT_STACK_CONTRACTID[];
+extern const char XPC_EXCEPTION_CONTRACTID[];
+extern const char XPC_CONSOLE_CONTRACTID[];
+extern const char XPC_SCRIPT_ERROR_CONTRACTID[];
+extern const char XPC_ID_CONTRACTID[];
+extern const char XPC_XPCONNECT_CONTRACTID[];
+
+/***************************************************************************/
+// Useful macros...
+
+#define XPC_STRING_GETTER_BODY(dest, src)                                     \
+    NS_ENSURE_ARG_POINTER(dest);                                              \
+    char* result;                                                             \
+    if (src)                                                                  \
+        result = (char*) nsMemory::Clone(src,                                 \
+                                         sizeof(char)*(strlen(src)+1));       \
+    else                                                                      \
+        result = nullptr;                                                      \
+    *dest = result;                                                           \
+    return (result || !src) ? NS_OK : NS_ERROR_OUT_OF_MEMORY
+
+// If IS_WN_CLASS for the JSClass of an object is true, the object is a
+// wrappednative wrapper, holding the XPCWrappedNative in its private slot.
+static inline bool IS_WN_CLASS(const js::Class* clazz)
+{
+    return clazz->isWrappedNative();
+}
+
+static inline bool IS_WN_REFLECTOR(JSObject* obj)
+{
+    return IS_WN_CLASS(js::GetObjectClass(obj));
+}
+
+/***************************************************************************
+****************************************************************************
+*
+* Core runtime and context classes...
+*
+****************************************************************************
+***************************************************************************/
+
+// We have a general rule internally that getters that return addref'd interface
+// pointer generally do so using an 'out' parm. When interface pointers are
+// returned as function call result values they are not addref'd. Exceptions
+// to this rule are noted explicitly.
+
+class nsXPConnect final : public nsIXPConnect
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCONNECT
+
+    // non-interface implementation
+public:
+    // These get non-addref'd pointers
+    static nsXPConnect*  XPConnect()
+    {
+        // Do a release-mode assert that we're not doing anything significant in
+        // XPConnect off the main thread. If you're an extension developer hitting
+        // this, you need to change your code. See bug 716167.
+        if (!MOZ_LIKELY(NS_IsMainThread()))
+            MOZ_CRASH();
+
+        return gSelf;
+    }
+
+    static XPCJSContext* GetContextInstance();
+    XPCJSContext* GetContext() {return mContext;}
+
+    static bool IsISupportsDescendant(nsIInterfaceInfo* info);
+
+    static nsIScriptSecurityManager* SecurityManager()
+    {
+        MOZ_ASSERT(NS_IsMainThread());
+        MOZ_ASSERT(gScriptSecurityManager);
+        return gScriptSecurityManager;
+    }
+
+    static nsIPrincipal* SystemPrincipal()
+    {
+        MOZ_ASSERT(NS_IsMainThread());
+        MOZ_ASSERT(gSystemPrincipal);
+        return gSystemPrincipal;
+    }
+
+    // This returns an AddRef'd pointer. It does not do this with an 'out' param
+    // only because this form is required by the generic module macro:
+    // NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR
+    static nsXPConnect* GetSingleton();
+
+    // Called by module code in dll startup
+    static void InitStatics();
+    // Called by module code on dll shutdown.
+    static void ReleaseXPConnectSingleton();
+
+    bool IsShuttingDown() const {return mShuttingDown;}
+
+    nsresult GetInfoForIID(const nsIID * aIID, nsIInterfaceInfo** info);
+    nsresult GetInfoForName(const char * name, nsIInterfaceInfo** info);
+
+    virtual nsIPrincipal* GetPrincipal(JSObject* obj,
+                                       bool allowShortCircuit) const override;
+
+    void RecordTraversal(void* p, nsISupports* s);
+    virtual char* DebugPrintJSStack(bool showArgs,
+                                    bool showLocals,
+                                    bool showThisProps) override;
+
+protected:
+    virtual ~nsXPConnect();
+
+    nsXPConnect();
+
+private:
+    // Singleton instance
+    static nsXPConnect*             gSelf;
+    static bool                     gOnceAliveNowDead;
+
+    XPCJSContext*                   mContext;
+    bool                            mShuttingDown;
+
+public:
+    static nsIScriptSecurityManager* gScriptSecurityManager;
+    static nsIPrincipal* gSystemPrincipal;
+};
+
+/***************************************************************************/
+
+class XPCRootSetElem
+{
+public:
+    XPCRootSetElem()
+    {
+#ifdef DEBUG
+        mNext = nullptr;
+        mSelfp = nullptr;
+#endif
+    }
+
+    ~XPCRootSetElem()
+    {
+        MOZ_ASSERT(!mNext, "Must be unlinked");
+        MOZ_ASSERT(!mSelfp, "Must be unlinked");
+    }
+
+    inline XPCRootSetElem* GetNextRoot() { return mNext; }
+    void AddToRootSet(XPCRootSetElem** listHead);
+    void RemoveFromRootSet();
+
+private:
+    XPCRootSetElem* mNext;
+    XPCRootSetElem** mSelfp;
+};
+
+/***************************************************************************/
+
+// In the current xpconnect system there can only be one XPCJSContext.
+// So, xpconnect can only be used on one JSContext within the process.
+
+class WatchdogManager;
+
+enum WatchdogTimestampCategory
+{
+    TimestampContextStateChange = 0,
+    TimestampWatchdogWakeup,
+    TimestampWatchdogHibernateStart,
+    TimestampWatchdogHibernateStop,
+    TimestampCount
+};
+
+class AsyncFreeSnowWhite;
+
+template <class StringType>
+class ShortLivedStringBuffer
+{
+public:
+    StringType* Create()
+    {
+        for (uint32_t i = 0; i < ArrayLength(mStrings); ++i) {
+            if (!mStrings[i]) {
+                mStrings[i].emplace();
+                return mStrings[i].ptr();
+            }
+        }
+
+        // All our internal string wrappers are used, allocate a new string.
+        return new StringType();
+    }
+
+    void Destroy(StringType* string)
+    {
+        for (uint32_t i = 0; i < ArrayLength(mStrings); ++i) {
+            if (mStrings[i] && mStrings[i].ptr() == string) {
+                // One of our internal strings is no longer in use, mark
+                // it as such and free its data.
+                mStrings[i].reset();
+                return;
+            }
+        }
+
+        // We're done with a string that's not one of our internal
+        // strings, delete it.
+        delete string;
+    }
+
+    ~ShortLivedStringBuffer()
+    {
+#ifdef DEBUG
+        for (uint32_t i = 0; i < ArrayLength(mStrings); ++i) {
+            MOZ_ASSERT(!mStrings[i], "Short lived string still in use");
+        }
+#endif
+    }
+
+private:
+    mozilla::Maybe<StringType> mStrings[2];
+};
+
+class XPCJSContext final : public mozilla::CycleCollectedJSContext
+{
+public:
+    static XPCJSContext* newXPCJSContext();
+    static XPCJSContext* Get() { return nsXPConnect::XPConnect()->GetContext(); }
+
+    void RemoveWrappedJS(nsXPCWrappedJS* wrapper);
+    void AssertInvalidWrappedJSNotInTable(nsXPCWrappedJS* wrapper) const;
+
+    XPCCallContext*  GetCallContext() const {return mCallContext;}
+    XPCCallContext*  SetCallContext(XPCCallContext* ccx)
+        {XPCCallContext* old = mCallContext; mCallContext = ccx; return old;}
+
+    jsid GetResolveName() const {return mResolveName;}
+    jsid SetResolveName(jsid name)
+        {jsid old = mResolveName; mResolveName = name; return old;}
+
+    XPCWrappedNative* GetResolvingWrapper() const {return mResolvingWrapper;}
+    XPCWrappedNative* SetResolvingWrapper(XPCWrappedNative* w)
+        {XPCWrappedNative* old = mResolvingWrapper;
+         mResolvingWrapper = w; return old;}
+
+    JSObject2WrappedJSMap* GetMultiCompartmentWrappedJSMap() const
+        {return mWrappedJSMap;}
+
+    IID2WrappedJSClassMap* GetWrappedJSClassMap() const
+        {return mWrappedJSClassMap;}
+
+    IID2NativeInterfaceMap* GetIID2NativeInterfaceMap() const
+        {return mIID2NativeInterfaceMap;}
+
+    ClassInfo2NativeSetMap* GetClassInfo2NativeSetMap() const
+        {return mClassInfo2NativeSetMap;}
+
+    NativeSetMap* GetNativeSetMap() const
+        {return mNativeSetMap;}
+
+    IID2ThisTranslatorMap* GetThisTranslatorMap() const
+        {return mThisTranslatorMap;}
+
+    XPCWrappedNativeProtoMap* GetDyingWrappedNativeProtoMap() const
+        {return mDyingWrappedNativeProtoMap;}
+
+    bool JSContextInitialized(JSContext* cx);
+
+    virtual bool
+    DescribeCustomObjects(JSObject* aObject, const js::Class* aClasp,
+                          char (&aName)[72]) const override;
+    virtual bool
+    NoteCustomGCThingXPCOMChildren(const js::Class* aClasp, JSObject* aObj,
+                                   nsCycleCollectionTraversalCallback& aCb) const override;
+
+    virtual void BeforeProcessTask(bool aMightBlock) override;
+    virtual void AfterProcessTask(uint32_t aNewRecursionDepth) override;
+
+    /**
+     * Infrastructure for classes that need to defer part of the finalization
+     * until after the GC has run, for example for objects that we don't want to
+     * destroy during the GC.
+     */
+
+public:
+    bool GetDoingFinalization() const {return mDoingFinalization;}
+
+    // Mapping of often used strings to jsid atoms that live 'forever'.
+    //
+    // To add a new string: add to this list and to XPCJSContext::mStrings
+    // at the top of XPCJSContext.cpp
+    enum {
+        IDX_CONSTRUCTOR             = 0 ,
+        IDX_TO_STRING               ,
+        IDX_TO_SOURCE               ,
+        IDX_LAST_RESULT             ,
+        IDX_RETURN_CODE             ,
+        IDX_VALUE                   ,
+        IDX_QUERY_INTERFACE         ,
+        IDX_COMPONENTS              ,
+        IDX_WRAPPED_JSOBJECT        ,
+        IDX_OBJECT                  ,
+        IDX_FUNCTION                ,
+        IDX_PROTOTYPE               ,
+        IDX_CREATE_INSTANCE         ,
+        IDX_ITEM                    ,
+        IDX_PROTO                   ,
+        IDX_ITERATOR                ,
+        IDX_EXPOSEDPROPS            ,
+        IDX_EVAL                    ,
+        IDX_CONTROLLERS             ,
+        IDX_REALFRAMEELEMENT        ,
+        IDX_LENGTH                  ,
+        IDX_NAME                    ,
+        IDX_UNDEFINED               ,
+        IDX_EMPTYSTRING             ,
+        IDX_FILENAME                ,
+        IDX_LINENUMBER              ,
+        IDX_COLUMNNUMBER            ,
+        IDX_STACK                   ,
+        IDX_MESSAGE                 ,
+        IDX_LASTINDEX               ,
+        IDX_TOTAL_COUNT // just a count of the above
+    };
+
+    JS::HandleId GetStringID(unsigned index) const
+    {
+        MOZ_ASSERT(index < IDX_TOTAL_COUNT, "index out of range");
+        // fromMarkedLocation() is safe because the string is interned.
+        return JS::HandleId::fromMarkedLocation(&mStrIDs[index]);
+    }
+    JS::HandleValue GetStringJSVal(unsigned index) const
+    {
+        MOZ_ASSERT(index < IDX_TOTAL_COUNT, "index out of range");
+        // fromMarkedLocation() is safe because the string is interned.
+        return JS::HandleValue::fromMarkedLocation(&mStrJSVals[index]);
+    }
+    const char* GetStringName(unsigned index) const
+    {
+        MOZ_ASSERT(index < IDX_TOTAL_COUNT, "index out of range");
+        return mStrings[index];
+    }
+
+    virtual bool UsefulToMergeZones() const override;
+    void TraceNativeBlackRoots(JSTracer* trc) override;
+    void TraceAdditionalNativeGrayRoots(JSTracer* aTracer) override;
+    void TraverseAdditionalNativeRoots(nsCycleCollectionNoteRootCallback& cb) override;
+    void UnmarkSkippableJSHolders();
+    void PrepareForForgetSkippable() override;
+    void BeginCycleCollectionCallback() override;
+    void EndCycleCollectionCallback(mozilla::CycleCollectorResults& aResults) override;
+    void DispatchDeferredDeletion(bool aContinuation, bool aPurge = false) override;
+
+    void CustomGCCallback(JSGCStatus status) override;
+    void CustomOutOfMemoryCallback() override;
+    void CustomLargeAllocationFailureCallback() override;
+    static void GCSliceCallback(JSContext* cx,
+                                JS::GCProgress progress,
+                                const JS::GCDescription& desc);
+    static void DoCycleCollectionCallback(JSContext* cx);
+    static void FinalizeCallback(JSFreeOp* fop,
+                                 JSFinalizeStatus status,
+                                 bool isZoneGC,
+                                 void* data);
+    static void WeakPointerZoneGroupCallback(JSContext* cx, void* data);
+    static void WeakPointerCompartmentCallback(JSContext* cx, JSCompartment* comp, void* data);
+
+    inline void AddVariantRoot(XPCTraceableVariant* variant);
+    inline void AddWrappedJSRoot(nsXPCWrappedJS* wrappedJS);
+    inline void AddObjectHolderRoot(XPCJSObjectHolder* holder);
+
+    void DebugDump(int16_t depth);
+
+    bool GCIsRunning() const {return mGCIsRunning;}
+
+    ~XPCJSContext();
+
+    ShortLivedStringBuffer<nsString> mScratchStrings;
+    ShortLivedStringBuffer<nsCString> mScratchCStrings;
+
+    void AddGCCallback(xpcGCCallback cb);
+    void RemoveGCCallback(xpcGCCallback cb);
+
+    static void ActivityCallback(void* arg, bool active);
+    static bool InterruptCallback(JSContext* cx);
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);
+
+    AutoMarkingPtr**  GetAutoRootsAdr() {return &mAutoRoots;}
+
+    JSObject* UnprivilegedJunkScope() { return mUnprivilegedJunkScope; }
+    JSObject* PrivilegedJunkScope() { return mPrivilegedJunkScope; }
+    JSObject* CompilationScope() { return mCompilationScope; }
+
+    void InitSingletonScopes();
+    void DeleteSingletonScopes();
+
+    PRTime GetWatchdogTimestamp(WatchdogTimestampCategory aCategory);
+
+    nsresult GetPendingResult() { return mPendingResult; }
+    void SetPendingResult(nsresult rv) { mPendingResult = rv; }
+
+private:
+    XPCJSContext();
+
+    MOZ_IS_CLASS_INIT
+    nsresult Initialize();
+
+    void ReleaseIncrementally(nsTArray<nsISupports*>& array);
+
+    static const char* const mStrings[IDX_TOTAL_COUNT];
+    jsid mStrIDs[IDX_TOTAL_COUNT];
+    JS::Value mStrJSVals[IDX_TOTAL_COUNT];
+
+    XPCCallContext*          mCallContext;
+    AutoMarkingPtr*          mAutoRoots;
+    jsid                     mResolveName;
+    XPCWrappedNative*        mResolvingWrapper;
+    JSObject2WrappedJSMap*   mWrappedJSMap;
+    IID2WrappedJSClassMap*   mWrappedJSClassMap;
+    IID2NativeInterfaceMap*  mIID2NativeInterfaceMap;
+    ClassInfo2NativeSetMap*  mClassInfo2NativeSetMap;
+    NativeSetMap*            mNativeSetMap;
+    IID2ThisTranslatorMap*   mThisTranslatorMap;
+    XPCWrappedNativeProtoMap* mDyingWrappedNativeProtoMap;
+    bool mGCIsRunning;
+    nsTArray<nsISupports*> mNativesToReleaseArray;
+    bool mDoingFinalization;
+    XPCRootSetElem* mVariantRoots;
+    XPCRootSetElem* mWrappedJSRoots;
+    XPCRootSetElem* mObjectHolderRoots;
+    nsTArray<xpcGCCallback> extraGCCallbacks;
+    RefPtr<WatchdogManager> mWatchdogManager;
+    JS::GCSliceCallback mPrevGCSliceCallback;
+    JS::DoCycleCollectionCallback mPrevDoCycleCollectionCallback;
+    JS::PersistentRootedObject mUnprivilegedJunkScope;
+    JS::PersistentRootedObject mPrivilegedJunkScope;
+    JS::PersistentRootedObject mCompilationScope;
+    RefPtr<AsyncFreeSnowWhite> mAsyncSnowWhiteFreer;
+
+    // If we spend too much time running JS code in an event handler, then we
+    // want to show the slow script UI. The timeout T is controlled by prefs. We
+    // invoke the interrupt callback once after T/2 seconds and set
+    // mSlowScriptSecondHalf to true. After another T/2 seconds, we invoke the
+    // interrupt callback again. Since mSlowScriptSecondHalf is now true, it
+    // shows the slow script UI. The reason we invoke the callback twice is to
+    // ensure that putting the computer to sleep while running a script doesn't
+    // cause the UI to be shown. If the laptop goes to sleep during one of the
+    // timeout periods, the script still has the other T/2 seconds to complete
+    // before the slow script UI is shown.
+    bool mSlowScriptSecondHalf;
+
+    // mSlowScriptCheckpoint is set to the time when:
+    // 1. We started processing the current event, or
+    // 2. mSlowScriptSecondHalf was set to true
+    // (whichever comes later). We use it to determine whether the interrupt
+    // callback needs to do anything.
+    mozilla::TimeStamp mSlowScriptCheckpoint;
+    // Accumulates total time we actually waited for telemetry
+    mozilla::TimeDuration mSlowScriptActualWait;
+    bool mTimeoutAccumulated;
+
+    // mPendingResult is used to implement Components.returnCode.  Only really
+    // meaningful while calling through XPCWrappedJS.
+    nsresult mPendingResult;
+
+    friend class Watchdog;
+    friend class AutoLockWatchdog;
+    friend class XPCIncrementalReleaseRunnable;
+};
+
+/***************************************************************************/
+
+// No virtuals
+// XPCCallContext is ALWAYS declared as a local variable in some function;
+// i.e. instance lifetime is always controled by some C++ function returning.
+//
+// These things are created frequently in many places. We *intentionally* do
+// not inialialize all members in order to save on construction overhead.
+// Some constructor pass more valid params than others. We init what must be
+// init'd and leave other members undefined. In debug builds the accessors
+// use a CHECK_STATE macro to track whether or not the object is in a valid
+// state to answer the question a caller might be asking. As long as this
+// class is maintained correctly it can do its job without a bunch of added
+// overhead from useless initializations and non-DEBUG error checking.
+//
+// Note that most accessors are inlined.
+
+class MOZ_STACK_CLASS XPCCallContext final : public nsAXPCNativeCallContext
+{
+public:
+    NS_IMETHOD GetCallee(nsISupports** aResult);
+    NS_IMETHOD GetCalleeMethodIndex(uint16_t* aResult);
+    NS_IMETHOD GetJSContext(JSContext** aResult);
+    NS_IMETHOD GetArgc(uint32_t* aResult);
+    NS_IMETHOD GetArgvPtr(JS::Value** aResult);
+    NS_IMETHOD GetCalleeInterface(nsIInterfaceInfo** aResult);
+    NS_IMETHOD GetCalleeClassInfo(nsIClassInfo** aResult);
+    NS_IMETHOD GetPreviousCallContext(nsAXPCNativeCallContext** aResult);
+
+    enum {NO_ARGS = (unsigned) -1};
+
+    explicit XPCCallContext(JSContext* cx,
+                            JS::HandleObject obj    = nullptr,
+                            JS::HandleObject funobj = nullptr,
+                            JS::HandleId id         = JSID_VOIDHANDLE,
+                            unsigned argc           = NO_ARGS,
+                            JS::Value* argv         = nullptr,
+                            JS::Value* rval         = nullptr);
+
+    virtual ~XPCCallContext();
+
+    inline bool                         IsValid() const ;
+
+    inline XPCJSContext*                GetContext() const ;
+    inline JSContext*                   GetJSContext() const ;
+    inline bool                         GetContextPopRequired() const ;
+    inline XPCCallContext*              GetPrevCallContext() const ;
+
+    inline JSObject*                    GetFlattenedJSObject() const ;
+    inline nsISupports*                 GetIdentityObject() const ;
+    inline XPCWrappedNative*            GetWrapper() const ;
+    inline XPCWrappedNativeProto*       GetProto() const ;
+
+    inline bool                         CanGetTearOff() const ;
+    inline XPCWrappedNativeTearOff*     GetTearOff() const ;
+
+    inline XPCNativeScriptableInfo*     GetScriptableInfo() const ;
+    inline bool                         CanGetSet() const ;
+    inline XPCNativeSet*                GetSet() const ;
+    inline bool                         CanGetInterface() const ;
+    inline XPCNativeInterface*          GetInterface() const ;
+    inline XPCNativeMember*             GetMember() const ;
+    inline bool                         HasInterfaceAndMember() const ;
+    inline jsid                         GetName() const ;
+    inline bool                         GetStaticMemberIsLocal() const ;
+    inline unsigned                     GetArgc() const ;
+    inline JS::Value*                   GetArgv() const ;
+    inline JS::Value*                   GetRetVal() const ;
+
+    inline uint16_t                     GetMethodIndex() const ;
+    inline void                         SetMethodIndex(uint16_t index) ;
+
+    inline jsid GetResolveName() const;
+    inline jsid SetResolveName(JS::HandleId name);
+
+    inline XPCWrappedNative* GetResolvingWrapper() const;
+    inline XPCWrappedNative* SetResolvingWrapper(XPCWrappedNative* w);
+
+    inline void SetRetVal(const JS::Value& val);
+
+    void SetName(jsid name);
+    void SetArgsAndResultPtr(unsigned argc, JS::Value* argv, JS::Value* rval);
+    void SetCallInfo(XPCNativeInterface* iface, XPCNativeMember* member,
+                     bool isSetter);
+
+    nsresult  CanCallNow();
+
+    void SystemIsBeingShutDown();
+
+    operator JSContext*() const {return GetJSContext();}
+
+private:
+
+    // no copy ctor or assignment allowed
+    XPCCallContext(const XPCCallContext& r) = delete;
+    XPCCallContext& operator= (const XPCCallContext& r) = delete;
+
+private:
+    // posible values for mState
+    enum State {
+        INIT_FAILED,
+        SYSTEM_SHUTDOWN,
+        HAVE_CONTEXT,
+        HAVE_OBJECT,
+        HAVE_NAME,
+        HAVE_ARGS,
+        READY_TO_CALL,
+        CALL_DONE
+    };
+
+#ifdef DEBUG
+inline void CHECK_STATE(int s) const {MOZ_ASSERT(mState >= s, "bad state");}
+#else
+#define CHECK_STATE(s) ((void)0)
+#endif
+
+private:
+    JSAutoRequest                   mAr;
+    State                           mState;
+
+    RefPtr<nsXPConnect>           mXPC;
+
+    XPCJSContext*                   mXPCJSContext;
+    JSContext*                      mJSContext;
+
+    // ctor does not necessarily init the following. BEWARE!
+
+    XPCCallContext*                 mPrevCallContext;
+
+    XPCWrappedNative*               mWrapper;
+    XPCWrappedNativeTearOff*        mTearOff;
+
+    XPCNativeScriptableInfo*        mScriptableInfo;
+
+    RefPtr<XPCNativeSet>            mSet;
+    RefPtr<XPCNativeInterface>      mInterface;
+    XPCNativeMember*                mMember;
+
+    JS::RootedId                    mName;
+    bool                            mStaticMemberIsLocal;
+
+    unsigned                        mArgc;
+    JS::Value*                      mArgv;
+    JS::Value*                      mRetVal;
+
+    uint16_t                        mMethodIndex;
+};
+
+/***************************************************************************
+****************************************************************************
+*
+* Core classes for wrapped native objects for use from JavaScript...
+*
+****************************************************************************
+***************************************************************************/
+
+// These are the various JSClasses and callbacks whose use that required
+// visibility from more than one .cpp file.
+
+extern const js::Class XPC_WN_NoHelper_JSClass;
+extern const js::Class XPC_WN_NoMods_Proto_JSClass;
+extern const js::Class XPC_WN_ModsAllowed_Proto_JSClass;
+extern const js::Class XPC_WN_Tearoff_JSClass;
+#define XPC_WN_TEAROFF_RESERVED_SLOTS 1
+#define XPC_WN_TEAROFF_FLAT_OBJECT_SLOT 0
+extern const js::Class XPC_WN_NoHelper_Proto_JSClass;
+
+extern bool
+XPC_WN_CallMethod(JSContext* cx, unsigned argc, JS::Value* vp);
+
+extern bool
+XPC_WN_GetterSetter(JSContext* cx, unsigned argc, JS::Value* vp);
+
+// Maybe this macro should check for class->enumerate ==
+// XPC_WN_Shared_Proto_Enumerate or something rather than checking for
+// 4 classes?
+static inline bool IS_PROTO_CLASS(const js::Class* clazz)
+{
+    return clazz == &XPC_WN_NoMods_Proto_JSClass ||
+           clazz == &XPC_WN_ModsAllowed_Proto_JSClass;
+}
+
+typedef js::HashSet<size_t,
+                    js::DefaultHasher<size_t>,
+                    js::SystemAllocPolicy> InterpositionWhitelist;
+
+struct InterpositionWhitelistPair {
+    nsIAddonInterposition* interposition;
+    InterpositionWhitelist whitelist;
+};
+
+typedef nsTArray<InterpositionWhitelistPair> InterpositionWhitelistArray;
+
+/***************************************************************************/
+// XPCWrappedNativeScope is one-to-one with a JS global object.
+
+class nsIAddonInterposition;
+class nsXPCComponentsBase;
+class XPCWrappedNativeScope final : public PRCList
+{
+public:
+
+    XPCJSContext*
+    GetContext() const {return XPCJSContext::Get();}
+
+    Native2WrappedNativeMap*
+    GetWrappedNativeMap() const {return mWrappedNativeMap;}
+
+    ClassInfo2WrappedNativeProtoMap*
+    GetWrappedNativeProtoMap() const {return mWrappedNativeProtoMap;}
+
+    nsXPCComponentsBase*
+    GetComponents() const {return mComponents;}
+
+    // Forces the creation of a privileged |Components| object, even in
+    // content scopes. This will crash if used outside of automation.
+    void
+    ForcePrivilegedComponents();
+
+    bool AttachComponentsObject(JSContext* aCx);
+
+    // Returns the JS object reflection of the Components object.
+    bool
+    GetComponentsJSObject(JS::MutableHandleObject obj);
+
+    JSObject*
+    GetGlobalJSObject() const {
+        return mGlobalJSObject;
+    }
+
+    JSObject*
+    GetGlobalJSObjectPreserveColor() const {return mGlobalJSObject.unbarrieredGet();}
+
+    nsIPrincipal*
+    GetPrincipal() const {
+        JSCompartment* c = js::GetObjectCompartment(mGlobalJSObject);
+        return nsJSPrincipals::get(JS_GetCompartmentPrincipals(c));
+    }
+
+    JSObject*
+    GetExpandoChain(JS::HandleObject target);
+
+    bool
+    SetExpandoChain(JSContext* cx, JS::HandleObject target, JS::HandleObject chain);
+
+    static void
+    SystemIsBeingShutDown();
+
+    static void
+    TraceWrappedNativesInAllScopes(JSTracer* trc, XPCJSContext* cx);
+
+    void TraceSelf(JSTracer* trc) {
+        MOZ_ASSERT(mGlobalJSObject);
+        mGlobalJSObject.trace(trc, "XPCWrappedNativeScope::mGlobalJSObject");
+    }
+
+    void TraceInside(JSTracer* trc) {
+        if (mContentXBLScope)
+            mContentXBLScope.trace(trc, "XPCWrappedNativeScope::mXBLScope");
+        for (size_t i = 0; i < mAddonScopes.Length(); i++)
+            mAddonScopes[i].trace(trc, "XPCWrappedNativeScope::mAddonScopes");
+        if (mXrayExpandos.initialized())
+            mXrayExpandos.trace(trc);
+    }
+
+    static void
+    SuspectAllWrappers(XPCJSContext* cx, nsCycleCollectionNoteRootCallback& cb);
+
+    static void
+    SweepAllWrappedNativeTearOffs();
+
+    static void
+    UpdateWeakPointersAfterGC(XPCJSContext* cx);
+
+    static void
+    KillDyingScopes();
+
+    static void
+    DebugDumpAllScopes(int16_t depth);
+
+    void
+    DebugDump(int16_t depth);
+
+    struct ScopeSizeInfo {
+        explicit ScopeSizeInfo(mozilla::MallocSizeOf mallocSizeOf)
+            : mMallocSizeOf(mallocSizeOf),
+              mScopeAndMapSize(0),
+              mProtoAndIfaceCacheSize(0)
+        {}
+
+        mozilla::MallocSizeOf mMallocSizeOf;
+        size_t mScopeAndMapSize;
+        size_t mProtoAndIfaceCacheSize;
+    };
+
+    static void
+    AddSizeOfAllScopesIncludingThis(ScopeSizeInfo* scopeSizeInfo);
+
+    void
+    AddSizeOfIncludingThis(ScopeSizeInfo* scopeSizeInfo);
+
+    bool
+    IsValid() const {return mContext != nullptr;}
+
+    static bool
+    IsDyingScope(XPCWrappedNativeScope* scope);
+
+    typedef js::HashSet<JS::Heap<JSObject*>,
+                        js::MovableCellHasher<JS::Heap<JSObject*>>,
+                        js::SystemAllocPolicy> DOMExpandoSet;
+
+    bool RegisterDOMExpandoObject(JSObject* expando) {
+        // Expandos are proxy objects, and proxies are always tenured.
+        JS::AssertGCThingMustBeTenured(expando);
+        if (!mDOMExpandoSet) {
+            mDOMExpandoSet = new DOMExpandoSet();
+            if (!mDOMExpandoSet->init(8))
+                return false;
+        }
+        return mDOMExpandoSet->put(JS::Heap<JSObject*>(expando));
+    }
+    void RemoveDOMExpandoObject(JSObject* expando) {
+        if (mDOMExpandoSet) {
+            DOMExpandoSet::Ptr p = mDOMExpandoSet->lookup(JS::Heap<JSObject*>(expando));
+            MOZ_ASSERT(p.found());
+            mDOMExpandoSet->remove(p);
+        }
+    }
+
+    typedef js::HashMap<JSAddonId*,
+                        nsCOMPtr<nsIAddonInterposition>,
+                        js::PointerHasher<JSAddonId*, 3>,
+                        js::SystemAllocPolicy> InterpositionMap;
+
+    typedef js::HashSet<JSAddonId*,
+                        js::PointerHasher<JSAddonId*, 3>,
+                        js::SystemAllocPolicy> AddonSet;
+
+    // Gets the appropriate scope object for XBL in this scope. The context
+    // must be same-compartment with the global upon entering, and the scope
+    // object is wrapped into the compartment of the global.
+    JSObject* EnsureContentXBLScope(JSContext* cx);
+
+    JSObject* EnsureAddonScope(JSContext* cx, JSAddonId* addonId);
+
+    XPCWrappedNativeScope(JSContext* cx, JS::HandleObject aGlobal);
+
+    nsAutoPtr<JSObject2JSObjectMap> mWaiverWrapperMap;
+
+    bool IsContentXBLScope() { return mIsContentXBLScope; }
+    bool AllowContentXBLScope();
+    bool UseContentXBLScope() { return mUseContentXBLScope; }
+    void ClearContentXBLScope() { mContentXBLScope = nullptr; }
+
+    bool IsAddonScope() { return mIsAddonScope; }
+
+    bool HasInterposition() { return mInterposition; }
+    nsCOMPtr<nsIAddonInterposition> GetInterposition();
+
+    static bool SetAddonInterposition(JSContext* cx,
+                                      JSAddonId* addonId,
+                                      nsIAddonInterposition* interp);
+
+    static InterpositionWhitelist* GetInterpositionWhitelist(nsIAddonInterposition* interposition);
+    static bool UpdateInterpositionWhitelist(JSContext* cx,
+                                             nsIAddonInterposition* interposition);
+
+    void SetAddonCallInterposition() { mHasCallInterpositions = true; }
+    bool HasCallInterposition() { return mHasCallInterpositions; };
+
+    static bool AllowCPOWsInAddon(JSContext* cx, JSAddonId* addonId, bool allow);
+
+protected:
+    virtual ~XPCWrappedNativeScope();
+
+    XPCWrappedNativeScope() = delete;
+
+private:
+    class ClearInterpositionsObserver final : public nsIObserver {
+        ~ClearInterpositionsObserver() {}
+
+      public:
+        NS_DECL_ISUPPORTS
+        NS_DECL_NSIOBSERVER
+    };
+
+    static XPCWrappedNativeScope* gScopes;
+    static XPCWrappedNativeScope* gDyingScopes;
+
+    static bool                      gShutdownObserverInitialized;
+    static InterpositionMap*         gInterpositionMap;
+    static AddonSet*                 gAllowCPOWAddonSet;
+
+    static InterpositionWhitelistArray* gInterpositionWhitelists;
+
+    XPCJSContext*                    mContext;
+    Native2WrappedNativeMap*         mWrappedNativeMap;
+    ClassInfo2WrappedNativeProtoMap* mWrappedNativeProtoMap;
+    RefPtr<nsXPCComponentsBase>    mComponents;
+    XPCWrappedNativeScope*           mNext;
+    // The JS global object for this scope.  If non-null, this will be the
+    // default parent for the XPCWrappedNatives that have us as the scope,
+    // unless a PreCreate hook overrides it.  Note that this _may_ be null (see
+    // constructor).
+    JS::ObjectPtr                    mGlobalJSObject;
+
+    // XBL Scope. This is is a lazily-created sandbox for non-system scopes.
+    // EnsureContentXBLScope() decides whether it needs to be created or not.
+    // This reference is wrapped into the compartment of mGlobalJSObject.
+    JS::ObjectPtr                    mContentXBLScope;
+
+    // Lazily created sandboxes for addon code.
+    nsTArray<JS::ObjectPtr>          mAddonScopes;
+
+    // This is a service that will be use to interpose on some property accesses on
+    // objects from other scope, for add-on compatibility reasons.
+    nsCOMPtr<nsIAddonInterposition>  mInterposition;
+
+    // If this flag is set, we intercept function calls on vanilla JS function objects
+    // from this scope if the caller scope has mInterposition set.
+    bool mHasCallInterpositions;
+
+    nsAutoPtr<DOMExpandoSet> mDOMExpandoSet;
+
+    JS::WeakMapPtr<JSObject*, JSObject*> mXrayExpandos;
+
+    bool mIsContentXBLScope;
+    bool mIsAddonScope;
+
+    // For remote XUL domains, we run all XBL in the content scope for compat
+    // reasons (though we sometimes pref this off for automation). We separately
+    // track the result of this decision (mAllowContentXBLScope), from the decision
+    // of whether to actually _use_ an XBL scope (mUseContentXBLScope), which depends
+    // on the type of global and whether the compartment is system principal
+    // or not.
+    //
+    // This distinction is useful primarily because, if true, we know that we
+    // have no way of distinguishing XBL script from content script for the
+    // given scope. In these (unsupported) situations, we just always claim to
+    // be XBL.
+    bool mAllowContentXBLScope;
+    bool mUseContentXBLScope;
+};
+
+/***************************************************************************/
+// Slots we use for our functions
+#define XPC_FUNCTION_NATIVE_MEMBER_SLOT 0
+#define XPC_FUNCTION_PARENT_OBJECT_SLOT 1
+
+/***************************************************************************/
+// XPCNativeMember represents a single idl declared method, attribute or
+// constant.
+
+// Tight. No virtual methods. Can be bitwise copied (until any resolution done).
+
+class XPCNativeMember final
+{
+public:
+    static bool GetCallInfo(JSObject* funobj,
+                            RefPtr<XPCNativeInterface>* pInterface,
+                            XPCNativeMember** pMember);
+
+    jsid   GetName() const {return mName;}
+
+    uint16_t GetIndex() const {return mIndex;}
+
+    bool GetConstantValue(XPCCallContext& ccx, XPCNativeInterface* iface,
+                          JS::Value* pval)
+        {MOZ_ASSERT(IsConstant(),
+                    "Only call this if you're sure this is a constant!");
+         return Resolve(ccx, iface, nullptr, pval);}
+
+    bool NewFunctionObject(XPCCallContext& ccx, XPCNativeInterface* iface,
+                           JS::HandleObject parent, JS::Value* pval);
+
+    bool IsMethod() const
+        {return 0 != (mFlags & METHOD);}
+
+    bool IsConstant() const
+        {return 0 != (mFlags & CONSTANT);}
+
+    bool IsAttribute() const
+        {return 0 != (mFlags & GETTER);}
+
+    bool IsWritableAttribute() const
+        {return 0 != (mFlags & SETTER_TOO);}
+
+    bool IsReadOnlyAttribute() const
+        {return IsAttribute() && !IsWritableAttribute();}
+
+
+    void SetName(jsid a) {mName = a;}
+
+    void SetMethod(uint16_t index)
+        {mFlags = METHOD; mIndex = index;}
+
+    void SetConstant(uint16_t index)
+        {mFlags = CONSTANT; mIndex = index;}
+
+    void SetReadOnlyAttribute(uint16_t index)
+        {mFlags = GETTER; mIndex = index;}
+
+    void SetWritableAttribute()
+        {MOZ_ASSERT(mFlags == GETTER,"bad"); mFlags = GETTER | SETTER_TOO;}
+
+    static uint16_t GetMaxIndexInInterface()
+        {return (1<<12) - 1;}
+
+    inline XPCNativeInterface* GetInterface() const;
+
+    void SetIndexInInterface(uint16_t index)
+        {mIndexInInterface = index;}
+
+    /* default ctor - leave random contents */
+    XPCNativeMember()  {MOZ_COUNT_CTOR(XPCNativeMember);}
+    ~XPCNativeMember() {MOZ_COUNT_DTOR(XPCNativeMember);}
+
+private:
+    bool Resolve(XPCCallContext& ccx, XPCNativeInterface* iface,
+                 JS::HandleObject parent, JS::Value* vp);
+
+    enum {
+        METHOD      = 0x01,
+        CONSTANT    = 0x02,
+        GETTER      = 0x04,
+        SETTER_TOO  = 0x08
+        // If you add a flag here, you may need to make mFlags wider and either
+        // make mIndexInInterface narrower (and adjust
+        // XPCNativeInterface::NewInstance accordingly) or make this object
+        // bigger.
+    };
+
+private:
+    // our only data...
+    jsid     mName;
+    uint16_t mIndex;
+    // mFlags needs to be wide enogh to hold the flags in the above enum.
+    uint16_t mFlags : 4;
+    // mIndexInInterface is the index of this in our XPCNativeInterface's
+    // mMembers.  In theory our XPCNativeInterface could have as many as 2^15-1
+    // members (since mMemberCount is 15-bit) but in practice we prevent
+    // creation of XPCNativeInterfaces which have more than 2^12 members.
+    // If the width of this field changes, update GetMaxIndexInInterface.
+    uint16_t mIndexInInterface : 12;
+} JS_HAZ_NON_GC_POINTER; // Only stores a pinned string
+
+/***************************************************************************/
+// XPCNativeInterface represents a single idl declared interface. This is
+// primarily the set of XPCNativeMembers.
+
+// Tight. No virtual methods.
+
+class XPCNativeInterface final
+{
+  public:
+    NS_INLINE_DECL_REFCOUNTING_WITH_DESTROY(XPCNativeInterface,
+                                            DestroyInstance(this))
+
+    static already_AddRefed<XPCNativeInterface> GetNewOrUsed(const nsIID* iid);
+    static already_AddRefed<XPCNativeInterface> GetNewOrUsed(nsIInterfaceInfo* info);
+    static already_AddRefed<XPCNativeInterface> GetNewOrUsed(const char* name);
+    static already_AddRefed<XPCNativeInterface> GetISupports();
+
+    inline nsIInterfaceInfo* GetInterfaceInfo() const {return mInfo.get();}
+    inline jsid              GetName()          const {return mName;}
+
+    inline const nsIID* GetIID() const;
+    inline const char*  GetNameString() const;
+    inline XPCNativeMember* FindMember(jsid name) const;
+
+    inline bool HasAncestor(const nsIID* iid) const;
+    static inline size_t OffsetOfMembers();
+
+    uint16_t GetMemberCount() const {
+        return mMemberCount;
+    }
+    XPCNativeMember* GetMemberAt(uint16_t i) {
+        MOZ_ASSERT(i < mMemberCount, "bad index");
+        return &mMembers[i];
+    }
+
+    void DebugDump(int16_t depth);
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);
+
+  protected:
+    static already_AddRefed<XPCNativeInterface> NewInstance(nsIInterfaceInfo* aInfo);
+
+    XPCNativeInterface() = delete;
+    XPCNativeInterface(nsIInterfaceInfo* aInfo, jsid aName)
+      : mInfo(aInfo), mName(aName), mMemberCount(0)
+    {}
+    ~XPCNativeInterface();
+
+    void* operator new(size_t, void* p) CPP_THROW_NEW {return p;}
+
+    XPCNativeInterface(const XPCNativeInterface& r) = delete;
+    XPCNativeInterface& operator= (const XPCNativeInterface& r) = delete;
+
+    static void DestroyInstance(XPCNativeInterface* inst);
+
+private:
+    nsCOMPtr<nsIInterfaceInfo> mInfo;
+    jsid                       mName;
+    uint16_t                   mMemberCount;
+    XPCNativeMember            mMembers[1]; // always last - object sized for array
+};
+
+/***************************************************************************/
+// XPCNativeSetKey is used to key a XPCNativeSet in a NativeSetMap.
+// It represents a new XPCNativeSet we are considering constructing, without
+// requiring that the set actually be built.
+
+class MOZ_STACK_CLASS XPCNativeSetKey final
+{
+public:
+    // This represents an existing set |baseSet|.
+    explicit XPCNativeSetKey(XPCNativeSet* baseSet)
+        : mBaseSet(baseSet), mAddition(nullptr)
+    {
+        MOZ_ASSERT(baseSet);
+    }
+
+    // This represents a new set containing only nsISupports and
+    // |addition|.
+    explicit XPCNativeSetKey(XPCNativeInterface* addition)
+        : mBaseSet(nullptr), mAddition(addition)
+    {
+        MOZ_ASSERT(addition);
+    }
+
+    // This represents the existing set |baseSet| with the interface
+    // |addition| inserted after existing interfaces. |addition| must
+    // not already be present in |baseSet|.
+    explicit XPCNativeSetKey(XPCNativeSet* baseSet,
+                             XPCNativeInterface* addition);
+    ~XPCNativeSetKey() {}
+
+    XPCNativeSet* GetBaseSet() const {return mBaseSet;}
+    XPCNativeInterface* GetAddition() const {return mAddition;}
+
+    PLDHashNumber Hash() const;
+
+    // Allow shallow copy
+
+private:
+    RefPtr<XPCNativeSet> mBaseSet;
+    RefPtr<XPCNativeInterface> mAddition;
+};
+
+/***************************************************************************/
+// XPCNativeSet represents an ordered collection of XPCNativeInterface pointers.
+
+class XPCNativeSet final
+{
+  public:
+    NS_INLINE_DECL_REFCOUNTING_WITH_DESTROY(XPCNativeSet,
+                                            DestroyInstance(this))
+
+    static already_AddRefed<XPCNativeSet> GetNewOrUsed(const nsIID* iid);
+    static already_AddRefed<XPCNativeSet> GetNewOrUsed(nsIClassInfo* classInfo);
+    static already_AddRefed<XPCNativeSet> GetNewOrUsed(XPCNativeSetKey* key);
+
+    // This generates a union set.
+    //
+    // If preserveFirstSetOrder is true, the elements from |firstSet| come first,
+    // followed by any non-duplicate items from |secondSet|. If false, the same
+    // algorithm is applied; but if we detect that |secondSet| is a superset of
+    // |firstSet|, we return |secondSet| without worrying about whether the
+    // ordering might differ from |firstSet|.
+    static already_AddRefed<XPCNativeSet> GetNewOrUsed(XPCNativeSet* firstSet,
+                                                       XPCNativeSet* secondSet,
+                                                       bool preserveFirstSetOrder);
+
+    static void ClearCacheEntryForClassInfo(nsIClassInfo* classInfo);
+
+    inline bool FindMember(jsid name, XPCNativeMember** pMember,
+                           uint16_t* pInterfaceIndex) const;
+
+    inline bool FindMember(jsid name, XPCNativeMember** pMember,
+                           RefPtr<XPCNativeInterface>* pInterface) const;
+
+    inline bool FindMember(JS::HandleId name,
+                           XPCNativeMember** pMember,
+                           RefPtr<XPCNativeInterface>* pInterface,
+                           XPCNativeSet* protoSet,
+                           bool* pIsLocal) const;
+
+    inline bool HasInterface(XPCNativeInterface* aInterface) const;
+    inline bool HasInterfaceWithAncestor(XPCNativeInterface* aInterface) const;
+    inline bool HasInterfaceWithAncestor(const nsIID* iid) const;
+
+    inline XPCNativeInterface* FindInterfaceWithIID(const nsIID& iid) const;
+
+    inline XPCNativeInterface* FindNamedInterface(jsid name) const;
+
+    uint16_t GetMemberCount() const {
+        return mMemberCount;
+    }
+    uint16_t GetInterfaceCount() const {
+        return mInterfaceCount;
+    }
+    XPCNativeInterface** GetInterfaceArray() {
+        return mInterfaces;
+    }
+
+    XPCNativeInterface* GetInterfaceAt(uint16_t i)
+        {MOZ_ASSERT(i < mInterfaceCount, "bad index"); return mInterfaces[i];}
+
+    inline bool MatchesSetUpToInterface(const XPCNativeSet* other,
+                                          XPCNativeInterface* iface) const;
+
+    void DebugDump(int16_t depth);
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);
+
+  protected:
+    static already_AddRefed<XPCNativeSet> NewInstance(nsTArray<RefPtr<XPCNativeInterface>>&& array);
+    static already_AddRefed<XPCNativeSet> NewInstanceMutate(XPCNativeSetKey* key);
+
+    XPCNativeSet()
+      : mMemberCount(0), mInterfaceCount(0)
+    {}
+    ~XPCNativeSet();
+    void* operator new(size_t, void* p) CPP_THROW_NEW {return p;}
+
+    static void DestroyInstance(XPCNativeSet* inst);
+
+  private:
+    uint16_t                mMemberCount;
+    uint16_t                mInterfaceCount;
+    // Always last - object sized for array.
+    // These are strong references.
+    XPCNativeInterface*     mInterfaces[1];
+};
+
+/***************************************************************************/
+// XPCNativeScriptableFlags is a wrapper class that holds the flags returned
+// from calls to nsIXPCScriptable::GetScriptableFlags(). It has convenience
+// methods to check for particular bitflags.
+
+class XPCNativeScriptableFlags final
+{
+public:
+    explicit XPCNativeScriptableFlags(uint32_t flags = 0) : mFlags(flags) {}
+
+    uint32_t GetFlags() const { return mFlags; }
+    void SetFlags(uint32_t flags) { mFlags = flags; }
+
+    operator uint32_t() const { return GetFlags(); }
+
+    XPCNativeScriptableFlags(const XPCNativeScriptableFlags& r)
+    {
+        mFlags = r.GetFlags();
+    }
+
+    XPCNativeScriptableFlags& operator= (const XPCNativeScriptableFlags& r)
+    {
+        mFlags = r.GetFlags();
+        return *this;
+    }
+
+#ifdef GET_IT
+#undef GET_IT
+#endif
+#define GET_IT(f_) const { return 0 != (mFlags & nsIXPCScriptable:: f_ ); }
+
+    bool WantPreCreate()                GET_IT(WANT_PRECREATE)
+    bool WantAddProperty()              GET_IT(WANT_ADDPROPERTY)
+    bool WantGetProperty()              GET_IT(WANT_GETPROPERTY)
+    bool WantSetProperty()              GET_IT(WANT_SETPROPERTY)
+    bool WantEnumerate()                GET_IT(WANT_ENUMERATE)
+    bool WantNewEnumerate()             GET_IT(WANT_NEWENUMERATE)
+    bool WantResolve()                  GET_IT(WANT_RESOLVE)
+    bool WantFinalize()                 GET_IT(WANT_FINALIZE)
+    bool WantCall()                     GET_IT(WANT_CALL)
+    bool WantConstruct()                GET_IT(WANT_CONSTRUCT)
+    bool WantHasInstance()              GET_IT(WANT_HASINSTANCE)
+    bool UseJSStubForAddProperty()      GET_IT(USE_JSSTUB_FOR_ADDPROPERTY)
+    bool UseJSStubForDelProperty()      GET_IT(USE_JSSTUB_FOR_DELPROPERTY)
+    bool UseJSStubForSetProperty()      GET_IT(USE_JSSTUB_FOR_SETPROPERTY)
+    bool DontEnumQueryInterface()       GET_IT(DONT_ENUM_QUERY_INTERFACE)
+    bool DontAskInstanceForScriptable() GET_IT(DONT_ASK_INSTANCE_FOR_SCRIPTABLE)
+    bool ClassInfoInterfacesOnly()      GET_IT(CLASSINFO_INTERFACES_ONLY)
+    bool AllowPropModsDuringResolve()   GET_IT(ALLOW_PROP_MODS_DURING_RESOLVE)
+    bool AllowPropModsToPrototype()     GET_IT(ALLOW_PROP_MODS_TO_PROTOTYPE)
+    bool IsGlobalObject()               GET_IT(IS_GLOBAL_OBJECT)
+    bool DontReflectInterfaceNames()    GET_IT(DONT_REFLECT_INTERFACE_NAMES)
+
+#undef GET_IT
+
+private:
+    uint32_t mFlags;
+};
+
+/***************************************************************************/
+// XPCNativeScriptableInfo is a trivial wrapper for nsIXPCScriptable which
+// should be removed eventually.
+
+class XPCNativeScriptableInfo final
+{
+public:
+    static XPCNativeScriptableInfo*
+    Construct(const XPCNativeScriptableCreateInfo* sci);
+
+    nsIXPCScriptable*
+    GetCallback() const { return mCallback; }
+
+    XPCNativeScriptableFlags
+    GetFlags() const { return XPCNativeScriptableFlags(mCallback->GetScriptableFlags()); }
+
+    const JSClass*
+    GetJSClass() { return Jsvalify(mCallback->GetClass()); }
+
+protected:
+    explicit XPCNativeScriptableInfo(nsIXPCScriptable* aCallback)
+        : mCallback(aCallback)
+    {
+        MOZ_COUNT_CTOR(XPCNativeScriptableInfo);
+    }
+public:
+    ~XPCNativeScriptableInfo()
+    {
+        MOZ_COUNT_DTOR(XPCNativeScriptableInfo);
+    }
+private:
+
+    // disable copy ctor and assignment
+    XPCNativeScriptableInfo(const XPCNativeScriptableInfo& r) = delete;
+    XPCNativeScriptableInfo& operator= (const XPCNativeScriptableInfo& r) = delete;
+
+private:
+    nsCOMPtr<nsIXPCScriptable> mCallback;
+};
+
+/***************************************************************************/
+// XPCNativeScriptableCreateInfo is used in creating new wrapper and protos.
+// it abstracts out the scriptable interface pointer and the flags. After
+// creation these are factored differently using XPCNativeScriptableInfo.
+
+class MOZ_STACK_CLASS XPCNativeScriptableCreateInfo final
+{
+public:
+
+    explicit XPCNativeScriptableCreateInfo(const XPCNativeScriptableInfo& si)
+        : mCallback(si.GetCallback()), mFlags(si.GetFlags()) {}
+
+    XPCNativeScriptableCreateInfo(already_AddRefed<nsIXPCScriptable>&& callback,
+                                  XPCNativeScriptableFlags flags)
+        : mCallback(callback), mFlags(flags) {}
+
+    XPCNativeScriptableCreateInfo()
+        : mFlags(0) {}
+
+
+    nsIXPCScriptable*
+    GetCallback() const {return mCallback;}
+
+    const XPCNativeScriptableFlags&
+    GetFlags() const      {return mFlags;}
+
+    void
+    SetCallback(already_AddRefed<nsIXPCScriptable>&& callback)
+        {mCallback = callback;}
+
+    void
+    SetFlags(const XPCNativeScriptableFlags& flags)  {mFlags = flags;}
+
+private:
+    // XXX: the flags are the same as the ones gettable from the callback. This
+    // redundancy should be removed eventually.
+    nsCOMPtr<nsIXPCScriptable>  mCallback;
+    XPCNativeScriptableFlags    mFlags;
+};
+
+/***********************************************/
+// XPCWrappedNativeProto hold the additional shared wrapper data
+// for XPCWrappedNative whose native objects expose nsIClassInfo.
+
+class XPCWrappedNativeProto final
+{
+public:
+    static XPCWrappedNativeProto*
+    GetNewOrUsed(XPCWrappedNativeScope* scope,
+                 nsIClassInfo* classInfo,
+                 const XPCNativeScriptableCreateInfo* scriptableCreateInfo,
+                 bool callPostCreatePrototype = true);
+
+    XPCWrappedNativeScope*
+    GetScope()   const {return mScope;}
+
+    XPCJSContext*
+    GetContext() const {return mScope->GetContext();}
+
+    JSObject*
+    GetJSProtoObject() const { return mJSProtoObject; }
+
+    nsIClassInfo*
+    GetClassInfo()     const {return mClassInfo;}
+
+    XPCNativeSet*
+    GetSet()           const {return mSet;}
+
+    XPCNativeScriptableInfo*
+    GetScriptableInfo()   {return mScriptableInfo;}
+
+    bool CallPostCreatePrototype();
+    void JSProtoObjectFinalized(js::FreeOp* fop, JSObject* obj);
+    void JSProtoObjectMoved(JSObject* obj, const JSObject* old);
+
+    void SystemIsBeingShutDown();
+
+    void DebugDump(int16_t depth);
+
+    void TraceSelf(JSTracer* trc) {
+        if (mJSProtoObject)
+            mJSProtoObject.trace(trc, "XPCWrappedNativeProto::mJSProtoObject");
+    }
+
+    void TraceInside(JSTracer* trc) {
+        GetScope()->TraceSelf(trc);
+    }
+
+    void TraceJS(JSTracer* trc) {
+        TraceSelf(trc);
+        TraceInside(trc);
+    }
+
+    void WriteBarrierPre(JSContext* cx)
+    {
+        if (JS::IsIncrementalBarrierNeeded(cx) && mJSProtoObject)
+            mJSProtoObject.writeBarrierPre(cx);
+    }
+
+    // NOP. This is just here to make the AutoMarkingPtr code compile.
+    void Mark() const {}
+    inline void AutoTrace(JSTracer* trc) {}
+
+    ~XPCWrappedNativeProto();
+
+protected:
+    // disable copy ctor and assignment
+    XPCWrappedNativeProto(const XPCWrappedNativeProto& r) = delete;
+    XPCWrappedNativeProto& operator= (const XPCWrappedNativeProto& r) = delete;
+
+    // hide ctor
+    XPCWrappedNativeProto(XPCWrappedNativeScope* Scope,
+                          nsIClassInfo* ClassInfo,
+                          already_AddRefed<XPCNativeSet>&& Set);
+
+    bool Init(const XPCNativeScriptableCreateInfo* scriptableCreateInfo,
+              bool callPostCreatePrototype);
+
+private:
+#ifdef DEBUG
+    static int32_t gDEBUG_LiveProtoCount;
+#endif
+
+private:
+    XPCWrappedNativeScope*   mScope;
+    JS::ObjectPtr            mJSProtoObject;
+    nsCOMPtr<nsIClassInfo>   mClassInfo;
+    RefPtr<XPCNativeSet>     mSet;
+    XPCNativeScriptableInfo* mScriptableInfo;
+};
+
+/***********************************************/
+// XPCWrappedNativeTearOff represents the info needed to make calls to one
+// interface on the underlying native object of a XPCWrappedNative.
+
+class XPCWrappedNativeTearOff final
+{
+public:
+    bool IsAvailable() const {return mInterface == nullptr;}
+    bool IsReserved()  const {return mInterface == (XPCNativeInterface*)1;}
+    bool IsValid()     const {return !IsAvailable() && !IsReserved();}
+    void   SetReserved()       {mInterface = (XPCNativeInterface*)1;}
+
+    XPCNativeInterface* GetInterface() const {return mInterface;}
+    nsISupports*        GetNative()    const {return mNative;}
+    JSObject*           GetJSObject();
+    JSObject*           GetJSObjectPreserveColor() const;
+    void SetInterface(XPCNativeInterface*  Interface) {mInterface = Interface;}
+    void SetNative(nsISupports*  Native)              {mNative = Native;}
+    already_AddRefed<nsISupports> TakeNative() { return mNative.forget(); }
+    void SetJSObject(JSObject*  JSObj);
+
+    void JSObjectFinalized() {SetJSObject(nullptr);}
+    void JSObjectMoved(JSObject* obj, const JSObject* old);
+
+    XPCWrappedNativeTearOff()
+        : mInterface(nullptr), mJSObject(nullptr)
+    {
+        MOZ_COUNT_CTOR(XPCWrappedNativeTearOff);
+    }
+    ~XPCWrappedNativeTearOff();
+
+    // NOP. This is just here to make the AutoMarkingPtr code compile.
+    inline void TraceJS(JSTracer* trc) {}
+    inline void AutoTrace(JSTracer* trc) {}
+
+    void Mark()       {mJSObject.setFlags(1);}
+    void Unmark()     {mJSObject.unsetFlags(1);}
+    bool IsMarked() const {return mJSObject.hasFlag(1);}
+
+    XPCWrappedNativeTearOff* AddTearOff()
+    {
+        MOZ_ASSERT(!mNextTearOff);
+        mNextTearOff = mozilla::MakeUnique<XPCWrappedNativeTearOff>();
+        return mNextTearOff.get();
+    }
+
+    XPCWrappedNativeTearOff* GetNextTearOff() {return mNextTearOff.get();}
+
+private:
+    XPCWrappedNativeTearOff(const XPCWrappedNativeTearOff& r) = delete;
+    XPCWrappedNativeTearOff& operator= (const XPCWrappedNativeTearOff& r) = delete;
+
+private:
+    XPCNativeInterface* mInterface;
+    // mNative is an nsRefPtr not an nsCOMPtr because it may not be the canonical
+    // nsISupports pointer.
+    RefPtr<nsISupports> mNative;
+    JS::TenuredHeap<JSObject*> mJSObject;
+    mozilla::UniquePtr<XPCWrappedNativeTearOff> mNextTearOff;
+};
+
+
+/***************************************************************************/
+// XPCWrappedNative the wrapper around one instance of a native xpcom object
+// to be used from JavaScript.
+
+class XPCWrappedNative final : public nsIXPConnectWrappedNative
+{
+public:
+    NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+    NS_DECL_NSIXPCONNECTJSOBJECTHOLDER
+    NS_DECL_NSIXPCONNECTWRAPPEDNATIVE
+
+    NS_DECL_CYCLE_COLLECTION_CLASS(XPCWrappedNative)
+
+    nsIPrincipal* GetObjectPrincipal() const;
+
+    bool
+    IsValid() const { return mFlatJSObject.hasFlag(FLAT_JS_OBJECT_VALID); }
+
+#define XPC_SCOPE_WORD(s)   (intptr_t(s))
+#define XPC_SCOPE_MASK      (intptr_t(0x3))
+#define XPC_SCOPE_TAG       (intptr_t(0x1))
+#define XPC_WRAPPER_EXPIRED (intptr_t(0x2))
+
+    static inline bool
+    IsTaggedScope(XPCWrappedNativeScope* s)
+        {return XPC_SCOPE_WORD(s) & XPC_SCOPE_TAG;}
+
+    static inline XPCWrappedNativeScope*
+    TagScope(XPCWrappedNativeScope* s)
+        {MOZ_ASSERT(!IsTaggedScope(s), "bad pointer!");
+         return (XPCWrappedNativeScope*)(XPC_SCOPE_WORD(s) | XPC_SCOPE_TAG);}
+
+    static inline XPCWrappedNativeScope*
+    UnTagScope(XPCWrappedNativeScope* s)
+        {return (XPCWrappedNativeScope*)(XPC_SCOPE_WORD(s) & ~XPC_SCOPE_TAG);}
+
+    inline bool
+    IsWrapperExpired() const
+        {return XPC_SCOPE_WORD(mMaybeScope) & XPC_WRAPPER_EXPIRED;}
+
+    bool
+    HasProto() const {return !IsTaggedScope(mMaybeScope);}
+
+    XPCWrappedNativeProto*
+    GetProto() const
+        {return HasProto() ?
+         (XPCWrappedNativeProto*)
+         (XPC_SCOPE_WORD(mMaybeProto) & ~XPC_SCOPE_MASK) : nullptr;}
+
+    void SetProto(XPCWrappedNativeProto* p);
+
+    XPCWrappedNativeScope*
+    GetScope() const
+        {return GetProto() ? GetProto()->GetScope() :
+         (XPCWrappedNativeScope*)
+         (XPC_SCOPE_WORD(mMaybeScope) & ~XPC_SCOPE_MASK);}
+
+    nsISupports*
+    GetIdentityObject() const {return mIdentity;}
+
+    /**
+     * This getter clears the gray bit before handing out the JSObject which
+     * means that the object is guaranteed to be kept alive past the next CC.
+     */
+    JSObject* GetFlatJSObject() const { return mFlatJSObject; }
+
+    /**
+     * This getter does not change the color of the JSObject meaning that the
+     * object returned is not guaranteed to be kept alive past the next CC.
+     *
+     * This should only be called if you are certain that the return value won't
+     * be passed into a JS API function and that it won't be stored without
+     * being rooted (or otherwise signaling the stored value to the CC).
+     */
+    JSObject*
+    GetFlatJSObjectPreserveColor() const {
+        return mFlatJSObject.unbarrieredGetPtr();
+    }
+
+    XPCNativeSet*
+    GetSet() const {return mSet;}
+
+    void
+    SetSet(already_AddRefed<XPCNativeSet> set) {mSet = set;}
+
+    static XPCWrappedNative* Get(JSObject* obj) {
+        MOZ_ASSERT(IS_WN_REFLECTOR(obj));
+        return (XPCWrappedNative*)js::GetObjectPrivate(obj);
+    }
+
+private:
+    inline void
+    ExpireWrapper()
+        {mMaybeScope = (XPCWrappedNativeScope*)
+                       (XPC_SCOPE_WORD(mMaybeScope) | XPC_WRAPPER_EXPIRED);}
+
+public:
+
+    XPCNativeScriptableInfo*
+    GetScriptableInfo() const {return mScriptableInfo;}
+
+    nsIXPCScriptable*      // call this wrong and you deserve to crash
+    GetScriptableCallback() const  {return mScriptableInfo->GetCallback();}
+
+    nsIClassInfo*
+    GetClassInfo() const {return IsValid() && HasProto() ?
+                            GetProto()->GetClassInfo() : nullptr;}
+
+    bool
+    HasMutatedSet() const {return IsValid() &&
+                                  (!HasProto() ||
+                                   GetSet() != GetProto()->GetSet());}
+
+    XPCJSContext*
+    GetContext() const {XPCWrappedNativeScope* scope = GetScope();
+                        return scope ? scope->GetContext() : nullptr;}
+
+    static nsresult
+    WrapNewGlobal(xpcObjectHelper& nativeHelper,
+                  nsIPrincipal* principal, bool initStandardClasses,
+                  JS::CompartmentOptions& aOptions,
+                  XPCWrappedNative** wrappedGlobal);
+
+    static nsresult
+    GetNewOrUsed(xpcObjectHelper& helper,
+                 XPCWrappedNativeScope* Scope,
+                 XPCNativeInterface* Interface,
+                 XPCWrappedNative** wrapper);
+
+    static nsresult
+    GetUsedOnly(nsISupports* Object,
+                XPCWrappedNativeScope* Scope,
+                XPCNativeInterface* Interface,
+                XPCWrappedNative** wrapper);
+
+    void FlatJSObjectFinalized();
+    void FlatJSObjectMoved(JSObject* obj, const JSObject* old);
+
+    void SystemIsBeingShutDown();
+
+    enum CallMode {CALL_METHOD, CALL_GETTER, CALL_SETTER};
+
+    static bool CallMethod(XPCCallContext& ccx,
+                           CallMode mode = CALL_METHOD);
+
+    static bool GetAttribute(XPCCallContext& ccx)
+        {return CallMethod(ccx, CALL_GETTER);}
+
+    static bool SetAttribute(XPCCallContext& ccx)
+        {return CallMethod(ccx, CALL_SETTER);}
+
+    inline bool HasInterfaceNoQI(const nsIID& iid);
+
+    XPCWrappedNativeTearOff* FindTearOff(XPCNativeInterface* aInterface,
+                                         bool needJSObject = false,
+                                         nsresult* pError = nullptr);
+    XPCWrappedNativeTearOff* FindTearOff(const nsIID& iid);
+
+    void Mark() const {}
+
+    inline void TraceInside(JSTracer* trc) {
+        if (HasProto())
+            GetProto()->TraceSelf(trc);
+        else
+            GetScope()->TraceSelf(trc);
+
+        JSObject* obj = mFlatJSObject.unbarrieredGetPtr();
+        if (obj && JS_IsGlobalObject(obj)) {
+            xpc::TraceXPCGlobal(trc, obj);
+        }
+    }
+
+    void TraceJS(JSTracer* trc) {
+        TraceInside(trc);
+    }
+
+    void TraceSelf(JSTracer* trc) {
+        // If this got called, we're being kept alive by someone who really
+        // needs us alive and whole.  Do not let our mFlatJSObject go away.
+        // This is the only time we should be tracing our mFlatJSObject,
+        // normally somebody else is doing that.
+        JS::TraceEdge(trc, &mFlatJSObject, "XPCWrappedNative::mFlatJSObject");
+    }
+
+    static void Trace(JSTracer* trc, JSObject* obj);
+
+    void AutoTrace(JSTracer* trc) {
+        TraceSelf(trc);
+    }
+
+    inline void SweepTearOffs();
+
+    // Returns a string that shuld be free'd using JS_smprintf_free (or null).
+    char* ToString(XPCWrappedNativeTearOff* to = nullptr) const;
+
+    static void GatherProtoScriptableCreateInfo(nsIClassInfo* classInfo,
+                                                XPCNativeScriptableCreateInfo& sciProto);
+
+    bool HasExternalReference() const {return mRefCnt > 1;}
+
+    void Suspect(nsCycleCollectionNoteRootCallback& cb);
+    void NoteTearoffs(nsCycleCollectionTraversalCallback& cb);
+
+    // Make ctor and dtor protected (rather than private) to placate nsCOMPtr.
+protected:
+    XPCWrappedNative() = delete;
+
+    // This ctor is used if this object will have a proto.
+    XPCWrappedNative(already_AddRefed<nsISupports>&& aIdentity,
+                     XPCWrappedNativeProto* aProto);
+
+    // This ctor is used if this object will NOT have a proto.
+    XPCWrappedNative(already_AddRefed<nsISupports>&& aIdentity,
+                     XPCWrappedNativeScope* aScope,
+                     already_AddRefed<XPCNativeSet>&& aSet);
+
+    virtual ~XPCWrappedNative();
+    void Destroy();
+
+    void UpdateScriptableInfo(XPCNativeScriptableInfo* si);
+
+private:
+    enum {
+        // Flags bits for mFlatJSObject:
+        FLAT_JS_OBJECT_VALID = JS_BIT(0)
+    };
+
+    bool Init(const XPCNativeScriptableCreateInfo* sci);
+    bool FinishInit();
+
+    bool ExtendSet(XPCNativeInterface* aInterface);
+
+    nsresult InitTearOff(XPCWrappedNativeTearOff* aTearOff,
+                         XPCNativeInterface* aInterface,
+                         bool needJSObject);
+
+    bool InitTearOffJSObject(XPCWrappedNativeTearOff* to);
+
+public:
+    static const XPCNativeScriptableCreateInfo& GatherScriptableCreateInfo(nsISupports* obj,
+                                                                           nsIClassInfo* classInfo,
+                                                                           XPCNativeScriptableCreateInfo& sciProto,
+                                                                           XPCNativeScriptableCreateInfo& sciWrapper);
+
+private:
+    union
+    {
+        XPCWrappedNativeScope* mMaybeScope;
+        XPCWrappedNativeProto* mMaybeProto;
+    };
+    RefPtr<XPCNativeSet> mSet;
+    JS::TenuredHeap<JSObject*> mFlatJSObject;
+    XPCNativeScriptableInfo* mScriptableInfo;
+    XPCWrappedNativeTearOff mFirstTearOff;
+};
+
+/***************************************************************************
+****************************************************************************
+*
+* Core classes for wrapped JSObject for use from native code...
+*
+****************************************************************************
+***************************************************************************/
+
+// this interfaces exists so we can refcount nsXPCWrappedJSClass
+// {2453EBA0-A9B8-11d2-BA64-00805F8A5DD7}
+#define NS_IXPCONNECT_WRAPPED_JS_CLASS_IID                                    \
+{ 0x2453eba0, 0xa9b8, 0x11d2,                                                 \
+  { 0xba, 0x64, 0x0, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 } }
+
+class nsIXPCWrappedJSClass : public nsISupports
+{
+public:
+    NS_DECLARE_STATIC_IID_ACCESSOR(NS_IXPCONNECT_WRAPPED_JS_CLASS_IID)
+    NS_IMETHOD DebugDump(int16_t depth) = 0;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsIXPCWrappedJSClass,
+                              NS_IXPCONNECT_WRAPPED_JS_CLASS_IID)
+
+/*************************/
+// nsXPCWrappedJSClass represents the sharable factored out common code and
+// data for nsXPCWrappedJS instances for the same interface type.
+
+class nsXPCWrappedJSClass final : public nsIXPCWrappedJSClass
+{
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_IMETHOD DebugDump(int16_t depth) override;
+public:
+
+    static already_AddRefed<nsXPCWrappedJSClass>
+    GetNewOrUsed(JSContext* cx,
+                 REFNSIID aIID,
+                 bool allowNonScriptable = false);
+
+    REFNSIID GetIID() const {return mIID;}
+    XPCJSContext* GetContext() const {return mContext;}
+    nsIInterfaceInfo* GetInterfaceInfo() const {return mInfo;}
+    const char* GetInterfaceName();
+
+    static bool IsWrappedJS(nsISupports* aPtr);
+
+    NS_IMETHOD DelegatedQueryInterface(nsXPCWrappedJS* self, REFNSIID aIID,
+                                       void** aInstancePtr);
+
+    JSObject* GetRootJSObject(JSContext* cx, JSObject* aJSObj);
+
+    NS_IMETHOD CallMethod(nsXPCWrappedJS* wrapper, uint16_t methodIndex,
+                          const XPTMethodDescriptor* info,
+                          nsXPTCMiniVariant* params);
+
+    JSObject*  CallQueryInterfaceOnJSObject(JSContext* cx,
+                                            JSObject* jsobj, REFNSIID aIID);
+
+    static nsresult BuildPropertyEnumerator(XPCCallContext& ccx,
+                                            JSObject* aJSObj,
+                                            nsISimpleEnumerator** aEnumerate);
+
+    static nsresult GetNamedPropertyAsVariant(XPCCallContext& ccx,
+                                              JSObject* aJSObj,
+                                              const nsAString& aName,
+                                              nsIVariant** aResult);
+
+private:
+    // aSyntheticException, if not null, is the exception we should be using.
+    // If null, look for an exception on the JSContext hanging off the
+    // XPCCallContext.
+    static nsresult CheckForException(XPCCallContext & ccx,
+                                      mozilla::dom::AutoEntryScript& aes,
+                                      const char * aPropertyName,
+                                      const char * anInterfaceName,
+                                      nsIException* aSyntheticException = nullptr);
+    virtual ~nsXPCWrappedJSClass();
+
+    nsXPCWrappedJSClass() = delete;
+    nsXPCWrappedJSClass(JSContext* cx, REFNSIID aIID,
+                        nsIInterfaceInfo* aInfo);
+
+    bool IsReflectable(uint16_t i) const
+        {return (bool)(mDescriptors[i/32] & (1 << (i%32)));}
+    void SetReflectable(uint16_t i, bool b)
+        {if (b) mDescriptors[i/32] |= (1 << (i%32));
+         else mDescriptors[i/32] &= ~(1 << (i%32));}
+
+    bool GetArraySizeFromParam(JSContext* cx,
+                               const XPTMethodDescriptor* method,
+                               const nsXPTParamInfo& param,
+                               uint16_t methodIndex,
+                               uint8_t paramIndex,
+                               nsXPTCMiniVariant* params,
+                               uint32_t* result) const;
+
+    bool GetInterfaceTypeFromParam(JSContext* cx,
+                                   const XPTMethodDescriptor* method,
+                                   const nsXPTParamInfo& param,
+                                   uint16_t methodIndex,
+                                   const nsXPTType& type,
+                                   nsXPTCMiniVariant* params,
+                                   nsID* result) const;
+
+    static void CleanupPointerArray(const nsXPTType& datum_type,
+                                    uint32_t array_count,
+                                    void** arrayp);
+
+    static void CleanupPointerTypeObject(const nsXPTType& type,
+                                         void** pp);
+
+    void CleanupOutparams(JSContext* cx, uint16_t methodIndex, const nsXPTMethodInfo* info,
+                          nsXPTCMiniVariant* nativeParams, bool inOutOnly, uint8_t n) const;
+
+private:
+    XPCJSContext* mContext;
+    nsCOMPtr<nsIInterfaceInfo> mInfo;
+    char* mName;
+    nsIID mIID;
+    uint32_t* mDescriptors;
+};
+
+/*************************/
+// nsXPCWrappedJS is a wrapper for a single JSObject for use from native code.
+// nsXPCWrappedJS objects are chained together to represent the various
+// interface on the single underlying (possibly aggregate) JSObject.
+
+class nsXPCWrappedJS final : protected nsAutoXPTCStub,
+                             public nsIXPConnectWrappedJSUnmarkGray,
+                             public nsSupportsWeakReference,
+                             public nsIPropertyBag,
+                             public XPCRootSetElem
+{
+public:
+    NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+    NS_DECL_NSIXPCONNECTJSOBJECTHOLDER
+    NS_DECL_NSIXPCONNECTWRAPPEDJS
+    NS_DECL_NSIXPCONNECTWRAPPEDJSUNMARKGRAY
+    NS_DECL_NSISUPPORTSWEAKREFERENCE
+    NS_DECL_NSIPROPERTYBAG
+
+    NS_DECL_CYCLE_COLLECTION_SKIPPABLE_CLASS_AMBIGUOUS(nsXPCWrappedJS, nsIXPConnectWrappedJS)
+
+    NS_IMETHOD CallMethod(uint16_t methodIndex,
+                          const XPTMethodDescriptor* info,
+                          nsXPTCMiniVariant* params) override;
+
+    /*
+    * This is rarely called directly. Instead one usually calls
+    * XPCConvert::JSObject2NativeInterface which will handles cases where the
+    * JS object is already a wrapped native or a DOM object.
+    */
+
+    static nsresult
+    GetNewOrUsed(JS::HandleObject aJSObj,
+                 REFNSIID aIID,
+                 nsXPCWrappedJS** wrapper);
+
+    nsISomeInterface* GetXPTCStub() { return mXPTCStub; }
+
+    /**
+     * This getter does not change the color of the JSObject meaning that the
+     * object returned is not guaranteed to be kept alive past the next CC.
+     *
+     * This should only be called if you are certain that the return value won't
+     * be passed into a JS API function and that it won't be stored without
+     * being rooted (or otherwise signaling the stored value to the CC).
+     */
+    JSObject* GetJSObjectPreserveColor() const { return mJSObj.unbarrieredGet(); }
+
+    // Returns true if the wrapper chain contains references to multiple
+    // compartments. If the wrapper chain contains references to multiple
+    // compartments, then it must be registered on the XPCJSContext. Otherwise,
+    // it should be registered in the CompartmentPrivate for the compartment of
+    // the root's JS object. This will only return correct results when called
+    // on the root wrapper and will assert if not called on a root wrapper.
+    bool IsMultiCompartment() const;
+
+    nsXPCWrappedJSClass*  GetClass() const {return mClass;}
+    REFNSIID GetIID() const {return GetClass()->GetIID();}
+    nsXPCWrappedJS* GetRootWrapper() const {return mRoot;}
+    nsXPCWrappedJS* GetNextWrapper() const {return mNext;}
+
+    nsXPCWrappedJS* Find(REFNSIID aIID);
+    nsXPCWrappedJS* FindInherited(REFNSIID aIID);
+    nsXPCWrappedJS* FindOrFindInherited(REFNSIID aIID) {
+        nsXPCWrappedJS* wrapper = Find(aIID);
+        if (wrapper)
+            return wrapper;
+        return FindInherited(aIID);
+    }
+
+    bool IsRootWrapper() const { return mRoot == this; }
+    bool IsValid() const { return bool(mJSObj); }
+    void SystemIsBeingShutDown();
+
+    // These two methods are used by JSObject2WrappedJSMap::FindDyingJSObjects
+    // to find non-rooting wrappers for dying JS objects. See the top of
+    // XPCWrappedJS.cpp for more details.
+    bool IsSubjectToFinalization() const {return IsValid() && mRefCnt == 1;}
+    void UpdateObjectPointerAfterGC() {JS_UpdateWeakPointerAfterGC(&mJSObj);}
+
+    bool IsAggregatedToNative() const {return mRoot->mOuter != nullptr;}
+    nsISupports* GetAggregatedNativeObject() const {return mRoot->mOuter;}
+    void SetAggregatedNativeObject(nsISupports* aNative) {
+        MOZ_ASSERT(aNative);
+        if (mRoot->mOuter) {
+            MOZ_ASSERT(mRoot->mOuter == aNative,
+                       "Only one aggregated native can be set");
+            return;
+        }
+        mRoot->mOuter = aNative;
+    }
+
+    void TraceJS(JSTracer* trc);
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
+    virtual ~nsXPCWrappedJS();
+protected:
+    nsXPCWrappedJS() = delete;
+    nsXPCWrappedJS(JSContext* cx,
+                   JSObject* aJSObj,
+                   nsXPCWrappedJSClass* aClass,
+                   nsXPCWrappedJS* root,
+                   nsresult* rv);
+
+    bool CanSkip();
+    void Destroy();
+    void Unlink();
+
+private:
+    JSCompartment* Compartment() const {
+        return js::GetObjectCompartment(mJSObj.unbarrieredGet());
+    }
+
+    JS::Heap<JSObject*> mJSObj;
+    RefPtr<nsXPCWrappedJSClass> mClass;
+    nsXPCWrappedJS* mRoot;    // If mRoot != this, it is an owning pointer.
+    nsXPCWrappedJS* mNext;
+    nsCOMPtr<nsISupports> mOuter;    // only set in root
+};
+
+/***************************************************************************/
+
+class XPCJSObjectHolder final : public nsIXPConnectJSObjectHolder,
+                                public XPCRootSetElem
+{
+public:
+    // all the interface method declarations...
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCONNECTJSOBJECTHOLDER
+
+    // non-interface implementation
+
+public:
+    void TraceJS(JSTracer* trc);
+
+    explicit XPCJSObjectHolder(JSObject* obj);
+
+private:
+    virtual ~XPCJSObjectHolder();
+
+    XPCJSObjectHolder() = delete;
+
+    JS::Heap<JSObject*> mJSObj;
+};
+
+/***************************************************************************
+****************************************************************************
+*
+* All manner of utility classes follow...
+*
+****************************************************************************
+***************************************************************************/
+
+class xpcProperty : public nsIProperty
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPROPERTY
+
+  xpcProperty(const char16_t* aName, uint32_t aNameLen, nsIVariant* aValue);
+
+private:
+    virtual ~xpcProperty() {}
+
+    nsString             mName;
+    nsCOMPtr<nsIVariant> mValue;
+};
+
+/***************************************************************************/
+// class here just for static methods
+class XPCConvert
+{
+public:
+    static bool IsMethodReflectable(const XPTMethodDescriptor& info);
+
+    /**
+     * Convert a native object into a JS::Value.
+     *
+     * @param d [out] the resulting JS::Value
+     * @param s the native object we're working with
+     * @param type the type of object that s is
+     * @param iid the interface of s that we want
+     * @param scope the default scope to put on the new JSObject's parent
+     *        chain
+     * @param pErr [out] relevant error code, if any.
+     */
+
+    static bool NativeData2JS(JS::MutableHandleValue d,
+                              const void* s, const nsXPTType& type,
+                              const nsID* iid, nsresult* pErr);
+
+    static bool JSData2Native(void* d, JS::HandleValue s,
+                              const nsXPTType& type,
+                              const nsID* iid,
+                              nsresult* pErr);
+
+    /**
+     * Convert a native nsISupports into a JSObject.
+     *
+     * @param dest [out] the resulting JSObject
+     * @param src the native object we're working with
+     * @param iid the interface of src that we want (may be null)
+     * @param cache the wrapper cache for src (may be null, in which case src
+     *              will be QI'ed to get the cache)
+     * @param allowNativeWrapper if true, this method may wrap the resulting
+     *        JSObject in an XPCNativeWrapper and return that, as needed.
+     * @param pErr [out] relevant error code, if any.
+     * @param src_is_identity optional performance hint. Set to true only
+     *                        if src is the identity pointer.
+     */
+    static bool NativeInterface2JSObject(JS::MutableHandleValue d,
+                                         nsIXPConnectJSObjectHolder** dest,
+                                         xpcObjectHelper& aHelper,
+                                         const nsID* iid,
+                                         bool allowNativeWrapper,
+                                         nsresult* pErr);
+
+    static bool GetNativeInterfaceFromJSObject(void** dest, JSObject* src,
+                                               const nsID* iid,
+                                               nsresult* pErr);
+    static bool JSObject2NativeInterface(void** dest, JS::HandleObject src,
+                                         const nsID* iid,
+                                         nsISupports* aOuter,
+                                         nsresult* pErr);
+
+    // Note - This return the XPCWrappedNative, rather than the native itself,
+    // for the WN case. You probably want UnwrapReflectorToISupports.
+    static bool GetISupportsFromJSObject(JSObject* obj, nsISupports** iface);
+
+    /**
+     * Convert a native array into a JS::Value.
+     *
+     * @param d [out] the resulting JS::Value
+     * @param s the native array we're working with
+     * @param type the type of objects in the array
+     * @param iid the interface of each object in the array that we want
+     * @param count the number of items in the array
+     * @param scope the default scope to put on the new JSObjects' parent chain
+     * @param pErr [out] relevant error code, if any.
+     */
+    static bool NativeArray2JS(JS::MutableHandleValue d, const void** s,
+                               const nsXPTType& type, const nsID* iid,
+                               uint32_t count, nsresult* pErr);
+
+    static bool JSArray2Native(void** d, JS::HandleValue s,
+                               uint32_t count, const nsXPTType& type,
+                               const nsID* iid, nsresult* pErr);
+
+    static bool JSTypedArray2Native(void** d,
+                                    JSObject* jsarray,
+                                    uint32_t count,
+                                    const nsXPTType& type,
+                                    nsresult* pErr);
+
+    static bool NativeStringWithSize2JS(JS::MutableHandleValue d, const void* s,
+                                        const nsXPTType& type,
+                                        uint32_t count,
+                                        nsresult* pErr);
+
+    static bool JSStringWithSize2Native(void* d, JS::HandleValue s,
+                                        uint32_t count, const nsXPTType& type,
+                                        nsresult* pErr);
+
+    static nsresult JSValToXPCException(JS::MutableHandleValue s,
+                                        const char* ifaceName,
+                                        const char* methodName,
+                                        nsIException** exception);
+
+    static nsresult ConstructException(nsresult rv, const char* message,
+                                       const char* ifaceName,
+                                       const char* methodName,
+                                       nsISupports* data,
+                                       nsIException** exception,
+                                       JSContext* cx,
+                                       JS::Value* jsExceptionPtr);
+
+private:
+    XPCConvert() = delete;
+
+};
+
+/***************************************************************************/
+// code for throwing exceptions into JS
+
+class nsXPCException;
+
+class XPCThrower
+{
+public:
+    static void Throw(nsresult rv, JSContext* cx);
+    static void Throw(nsresult rv, XPCCallContext& ccx);
+    static void ThrowBadResult(nsresult rv, nsresult result, XPCCallContext& ccx);
+    static void ThrowBadParam(nsresult rv, unsigned paramNum, XPCCallContext& ccx);
+    static bool SetVerbosity(bool state)
+        {bool old = sVerbose; sVerbose = state; return old;}
+
+    static bool CheckForPendingException(nsresult result, JSContext* cx);
+
+private:
+    static void Verbosify(XPCCallContext& ccx,
+                          char** psz, bool own);
+
+private:
+    static bool sVerbose;
+};
+
+/***************************************************************************/
+
+class nsXPCException
+{
+public:
+    static bool NameAndFormatForNSResult(nsresult rv,
+                                         const char** name,
+                                         const char** format);
+
+    static const void* IterateNSResults(nsresult* rv,
+                                        const char** name,
+                                        const char** format,
+                                        const void** iterp);
+
+    static uint32_t GetNSResultCount();
+};
+
+/***************************************************************************/
+/*
+* nsJSID implements nsIJSID. It is also used by nsJSIID and nsJSCID as a
+* member (as a hidden implementaion detail) to which they delegate many calls.
+*/
+
+// Initialization is done on demand, and calling the destructor below is always
+// safe.
+extern void xpc_DestroyJSxIDClassObjects();
+
+class nsJSID final : public nsIJSID
+{
+public:
+    NS_DEFINE_STATIC_CID_ACCESSOR(NS_JS_ID_CID)
+
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIJSID
+
+    bool InitWithName(const nsID& id, const char* nameString);
+    bool SetName(const char* name);
+    void   SetNameToNoString()
+        {MOZ_ASSERT(!mName, "name already set"); mName = const_cast<char*>(gNoString);}
+    bool NameIsSet() const {return nullptr != mName;}
+    const nsID& ID() const {return mID;}
+    bool IsValid() const {return !mID.Equals(GetInvalidIID());}
+
+    static already_AddRefed<nsJSID> NewID(const char* str);
+    static already_AddRefed<nsJSID> NewID(const nsID& id);
+
+    nsJSID();
+
+    void Reset();
+    const nsID& GetInvalidIID() const;
+
+protected:
+    virtual ~nsJSID();
+    static const char gNoString[];
+    nsID    mID;
+    char*   mNumber;
+    char*   mName;
+};
+
+
+// nsJSIID
+
+class nsJSIID : public nsIJSIID,
+                public nsIXPCScriptable
+{
+public:
+    NS_DECL_ISUPPORTS
+
+    // we manually delagate these to nsJSID
+    NS_DECL_NSIJSID
+
+    // we implement the rest...
+    NS_DECL_NSIJSIID
+    NS_DECL_NSIXPCSCRIPTABLE
+
+    static already_AddRefed<nsJSIID> NewID(nsIInterfaceInfo* aInfo);
+
+    explicit nsJSIID(nsIInterfaceInfo* aInfo);
+    nsJSIID() = delete;
+
+private:
+    virtual ~nsJSIID();
+
+    nsCOMPtr<nsIInterfaceInfo> mInfo;
+};
+
+// nsJSCID
+
+class nsJSCID : public nsIJSCID, public nsIXPCScriptable
+{
+public:
+    NS_DECL_ISUPPORTS
+
+    // we manually delagate these to nsJSID
+    NS_DECL_NSIJSID
+
+    // we implement the rest...
+    NS_DECL_NSIJSCID
+    NS_DECL_NSIXPCSCRIPTABLE
+
+    static already_AddRefed<nsJSCID> NewID(const char* str);
+
+    nsJSCID();
+
+private:
+    virtual ~nsJSCID();
+
+    void ResolveName();
+
+private:
+    RefPtr<nsJSID> mDetails;
+};
+
+
+/***************************************************************************/
+// 'Components' object implementations. nsXPCComponentsBase has the
+// less-privileged stuff that we're willing to expose to XBL.
+
+class nsXPCComponentsBase : public nsIXPCComponentsBase
+{
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIXPCCOMPONENTSBASE
+
+public:
+    void SystemIsBeingShutDown() { ClearMembers(); }
+
+    XPCWrappedNativeScope* GetScope() { return mScope; }
+
+protected:
+    virtual ~nsXPCComponentsBase();
+
+    explicit nsXPCComponentsBase(XPCWrappedNativeScope* aScope);
+    virtual void ClearMembers();
+
+    XPCWrappedNativeScope*                   mScope;
+
+    // Unprivileged members from nsIXPCComponentsBase.
+    RefPtr<nsXPCComponents_Interfaces>     mInterfaces;
+    RefPtr<nsXPCComponents_InterfacesByID> mInterfacesByID;
+    RefPtr<nsXPCComponents_Results>        mResults;
+
+    friend class XPCWrappedNativeScope;
+};
+
+class nsXPCComponents : public nsXPCComponentsBase,
+                        public nsIXPCComponents
+{
+public:
+    NS_DECL_ISUPPORTS_INHERITED
+    NS_FORWARD_NSIXPCCOMPONENTSBASE(nsXPCComponentsBase::)
+    NS_DECL_NSIXPCCOMPONENTS
+
+protected:
+    explicit nsXPCComponents(XPCWrappedNativeScope* aScope);
+    virtual ~nsXPCComponents();
+    virtual void ClearMembers() override;
+
+    // Privileged members added by nsIXPCComponents.
+    RefPtr<nsXPCComponents_Classes>     mClasses;
+    RefPtr<nsXPCComponents_ClassesByID> mClassesByID;
+    RefPtr<nsXPCComponents_ID>          mID;
+    RefPtr<nsXPCComponents_Exception>   mException;
+    RefPtr<nsXPCComponents_Constructor> mConstructor;
+    RefPtr<nsXPCComponents_Utils>       mUtils;
+
+    friend class XPCWrappedNativeScope;
+};
+
+
+/***************************************************************************/
+
+extern JSObject*
+xpc_NewIDObject(JSContext* cx, JS::HandleObject jsobj, const nsID& aID);
+
+extern const nsID*
+xpc_JSObjectToID(JSContext* cx, JSObject* obj);
+
+extern bool
+xpc_JSObjectIsID(JSContext* cx, JSObject* obj);
+
+/***************************************************************************/
+// in XPCDebug.cpp
+
+extern bool
+xpc_DumpJSStack(bool showArgs, bool showLocals, bool showThisProps);
+
+// Return a newly-allocated string containing a representation of the
+// current JS stack.  It is the *caller's* responsibility to free this
+// string with JS_smprintf_free().
+extern char*
+xpc_PrintJSStack(JSContext* cx, bool showArgs, bool showLocals,
+                 bool showThisProps);
+
+/***************************************************************************/
+
+// Definition of nsScriptError, defined here because we lack a place to put
+// XPCOM objects associated with the JavaScript engine.
+class nsScriptErrorBase : public nsIScriptError {
+public:
+    nsScriptErrorBase();
+
+  // TODO - do something reasonable on getting null from these babies.
+
+    NS_DECL_NSICONSOLEMESSAGE
+    NS_DECL_NSISCRIPTERROR
+
+protected:
+    virtual ~nsScriptErrorBase();
+
+    void
+    InitializeOnMainThread();
+
+    nsString mMessage;
+    nsString mMessageName;
+    nsString mSourceName;
+    uint32_t mLineNumber;
+    nsString mSourceLine;
+    uint32_t mColumnNumber;
+    uint32_t mFlags;
+    nsCString mCategory;
+    // mOuterWindowID is set on the main thread from InitializeOnMainThread().
+    uint64_t mOuterWindowID;
+    uint64_t mInnerWindowID;
+    int64_t mTimeStamp;
+    // mInitializedOnMainThread and mIsFromPrivateWindow are set on the main
+    // thread from InitializeOnMainThread().
+    mozilla::Atomic<bool> mInitializedOnMainThread;
+    bool mIsFromPrivateWindow;
+};
+
+class nsScriptError final : public nsScriptErrorBase {
+public:
+    nsScriptError() {}
+    NS_DECL_THREADSAFE_ISUPPORTS
+
+private:
+    virtual ~nsScriptError() {}
+};
+
+class nsScriptErrorWithStack : public nsScriptErrorBase {
+public:
+    explicit nsScriptErrorWithStack(JS::HandleObject);
+
+    NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+    NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsScriptErrorWithStack)
+
+    NS_IMETHOD Init(const nsAString& message,
+                    const nsAString& sourceName,
+                    const nsAString& sourceLine,
+                    uint32_t lineNumber,
+                    uint32_t columnNumber,
+                    uint32_t flags,
+                    const char* category) override;
+
+    NS_IMETHOD GetStack(JS::MutableHandleValue) override;
+    NS_IMETHOD ToString(nsACString& aResult) override;
+
+private:
+    virtual ~nsScriptErrorWithStack();
+    // Complete stackframe where the error happened.
+    // Must be SavedFrame object.
+    JS::Heap<JSObject*>  mStack;
+};
+
+/******************************************************************************
+ * Handles pre/post script processing.
+ */
+class MOZ_RAII AutoScriptEvaluate
+{
+public:
+    /**
+     * Saves the JSContext as well as initializing our state
+     * @param cx The JSContext, this can be null, we don't do anything then
+     */
+    explicit AutoScriptEvaluate(JSContext * cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+         : mJSContext(cx), mEvaluated(false) {
+        MOZ_GUARD_OBJECT_NOTIFIER_INIT;
+    }
+
+    /**
+     * Does the pre script evaluation.
+     * This function should only be called once, and will assert if called
+     * more than once
+     */
+
+    bool StartEvaluating(JS::HandleObject scope);
+
+    /**
+     * Does the post script evaluation.
+     */
+    ~AutoScriptEvaluate();
+private:
+    JSContext* mJSContext;
+    mozilla::Maybe<JS::AutoSaveExceptionState> mState;
+    bool mEvaluated;
+    mozilla::Maybe<JSAutoCompartment> mAutoCompartment;
+    MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
+
+    // No copying or assignment allowed
+    AutoScriptEvaluate(const AutoScriptEvaluate&) = delete;
+    AutoScriptEvaluate & operator =(const AutoScriptEvaluate&) = delete;
+};
+
+/***************************************************************************/
+class MOZ_RAII AutoResolveName
+{
+public:
+    AutoResolveName(XPCCallContext& ccx, JS::HandleId name
+                    MOZ_GUARD_OBJECT_NOTIFIER_PARAM) :
+          mOld(ccx, XPCJSContext::Get()->SetResolveName(name))
+#ifdef DEBUG
+          ,mCheck(ccx, name)
+#endif
+    {
+        MOZ_GUARD_OBJECT_NOTIFIER_INIT;
+    }
+    ~AutoResolveName()
+        {
+#ifdef DEBUG
+            jsid old =
+#endif
+            XPCJSContext::Get()->SetResolveName(mOld);
+            MOZ_ASSERT(old == mCheck, "Bad Nesting!");
+        }
+
+private:
+    JS::RootedId mOld;
+#ifdef DEBUG
+    JS::RootedId mCheck;
+#endif
+    MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
+};
+
+/***************************************************************************/
+// AutoMarkingPtr is the base class for the various AutoMarking pointer types
+// below. This system allows us to temporarily protect instances of our garbage
+// collected types after they are constructed but before they are safely
+// attached to other rooted objects.
+// This base class has pure virtual support for marking.
+
+class AutoMarkingPtr
+{
+  public:
+    explicit AutoMarkingPtr(JSContext* cx) {
+        mRoot = XPCJSContext::Get()->GetAutoRootsAdr();
+        mNext = *mRoot;
+        *mRoot = this;
+    }
+
+    virtual ~AutoMarkingPtr() {
+        if (mRoot) {
+            MOZ_ASSERT(*mRoot == this);
+            *mRoot = mNext;
+        }
+    }
+
+    void TraceJSAll(JSTracer* trc) {
+        for (AutoMarkingPtr* cur = this; cur; cur = cur->mNext)
+            cur->TraceJS(trc);
+    }
+
+    void MarkAfterJSFinalizeAll() {
+        for (AutoMarkingPtr* cur = this; cur; cur = cur->mNext)
+            cur->MarkAfterJSFinalize();
+    }
+
+  protected:
+    virtual void TraceJS(JSTracer* trc) = 0;
+    virtual void MarkAfterJSFinalize() = 0;
+
+  private:
+    AutoMarkingPtr** mRoot;
+    AutoMarkingPtr* mNext;
+};
+
+template<class T>
+class TypedAutoMarkingPtr : public AutoMarkingPtr
+{
+  public:
+    explicit TypedAutoMarkingPtr(JSContext* cx) : AutoMarkingPtr(cx), mPtr(nullptr) {}
+    TypedAutoMarkingPtr(JSContext* cx, T* ptr) : AutoMarkingPtr(cx), mPtr(ptr) {}
+
+    T* get() const { return mPtr; }
+    operator T*() const { return mPtr; }
+    T* operator->() const { return mPtr; }
+
+    TypedAutoMarkingPtr<T>& operator =(T* ptr) { mPtr = ptr; return *this; }
+
+  protected:
+    virtual void TraceJS(JSTracer* trc)
+    {
+        if (mPtr) {
+            mPtr->TraceJS(trc);
+            mPtr->AutoTrace(trc);
+        }
+    }
+
+    virtual void MarkAfterJSFinalize()
+    {
+        if (mPtr)
+            mPtr->Mark();
+    }
+
+  private:
+    T* mPtr;
+};
+
+typedef TypedAutoMarkingPtr<XPCWrappedNative> AutoMarkingWrappedNativePtr;
+typedef TypedAutoMarkingPtr<XPCWrappedNativeTearOff> AutoMarkingWrappedNativeTearOffPtr;
+typedef TypedAutoMarkingPtr<XPCWrappedNativeProto> AutoMarkingWrappedNativeProtoPtr;
+
+/***************************************************************************/
+namespace xpc {
+// Allocates a string that grants all access ("AllAccess")
+char*
+CloneAllAccess();
+
+// Returns access if wideName is in list
+char*
+CheckAccessList(const char16_t* wideName, const char* const list[]);
+} /* namespace xpc */
+
+/***************************************************************************/
+// in xpcvariant.cpp...
+
+// {1809FD50-91E8-11d5-90F9-0010A4E73D9A}
+#define XPCVARIANT_IID                                                        \
+    {0x1809fd50, 0x91e8, 0x11d5,                                              \
+      { 0x90, 0xf9, 0x0, 0x10, 0xa4, 0xe7, 0x3d, 0x9a } }
+
+// {DC524540-487E-4501-9AC7-AAA784B17C1C}
+#define XPCVARIANT_CID                                                        \
+    {0xdc524540, 0x487e, 0x4501,                                              \
+      { 0x9a, 0xc7, 0xaa, 0xa7, 0x84, 0xb1, 0x7c, 0x1c } }
+
+class XPCVariant : public nsIVariant
+{
+public:
+    NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+    NS_DECL_NSIVARIANT
+    NS_DECL_CYCLE_COLLECTION_CLASS(XPCVariant)
+
+    // If this class ever implements nsIWritableVariant, take special care with
+    // the case when mJSVal is JSVAL_STRING, since we don't own the data in
+    // that case.
+
+    // We #define and iid so that out module local code can use QI to detect
+    // if a given nsIVariant is in fact an XPCVariant.
+    NS_DECLARE_STATIC_IID_ACCESSOR(XPCVARIANT_IID)
+
+    static already_AddRefed<XPCVariant> newVariant(JSContext* cx, const JS::Value& aJSVal);
+
+    /**
+     * This getter clears the gray bit before handing out the Value if the Value
+     * represents a JSObject. That means that the object is guaranteed to be
+     * kept alive past the next CC.
+     */
+    JS::Value GetJSVal() const {
+        return mJSVal;
+    }
+
+    /**
+     * This getter does not change the color of the Value (if it represents a
+     * JSObject) meaning that the value returned is not guaranteed to be kept
+     * alive past the next CC.
+     *
+     * This should only be called if you are certain that the return value won't
+     * be passed into a JS API function and that it won't be stored without
+     * being rooted (or otherwise signaling the stored value to the CC).
+     */
+    JS::Value GetJSValPreserveColor() const { return mJSVal.unbarrieredGet(); }
+
+    XPCVariant(JSContext* cx, const JS::Value& aJSVal);
+
+    /**
+     * Convert a variant into a JS::Value.
+     *
+     * @param ccx the context for the whole procedure
+     * @param variant the variant to convert
+     * @param scope the default scope to put on the new JSObject's parent chain
+     * @param pErr [out] relevant error code, if any.
+     * @param pJSVal [out] the resulting jsval.
+     */
+    static bool VariantDataToJS(nsIVariant* variant,
+                                nsresult* pErr, JS::MutableHandleValue pJSVal);
+
+    bool IsPurple()
+    {
+        return mRefCnt.IsPurple();
+    }
+
+    void RemovePurple()
+    {
+        mRefCnt.RemovePurple();
+    }
+
+    void SetCCGeneration(uint32_t aGen)
+    {
+        mCCGeneration = aGen;
+    }
+
+    uint32_t CCGeneration() { return mCCGeneration; }
+protected:
+    virtual ~XPCVariant() { }
+
+    bool InitializeData(JSContext* cx);
+
+protected:
+    nsDiscriminatedUnion mData;
+    JS::Heap<JS::Value>  mJSVal;
+    bool                 mReturnRawObject : 1;
+    uint32_t             mCCGeneration : 31;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(XPCVariant, XPCVARIANT_IID)
+
+class XPCTraceableVariant: public XPCVariant,
+                           public XPCRootSetElem
+{
+public:
+    XPCTraceableVariant(JSContext* cx, const JS::Value& aJSVal)
+        : XPCVariant(cx, aJSVal)
+    {
+         nsXPConnect::GetContextInstance()->AddVariantRoot(this);
+    }
+
+    virtual ~XPCTraceableVariant();
+
+    void TraceJS(JSTracer* trc);
+};
+
+/***************************************************************************/
+// Utilities
+
+inline void*
+xpc_GetJSPrivate(JSObject* obj)
+{
+    return js::GetObjectPrivate(obj);
+}
+
+inline JSContext*
+xpc_GetSafeJSContext()
+{
+    return XPCJSContext::Get()->Context();
+}
+
+namespace xpc {
+
+JSAddonId*
+NewAddonId(JSContext* cx, const nsACString& id);
+
+// JSNatives to expose atob and btoa in various non-DOM XPConnect scopes.
+bool
+Atob(JSContext* cx, unsigned argc, JS::Value* vp);
+
+bool
+Btoa(JSContext* cx, unsigned argc, JS::Value* vp);
+
+// Helper function that creates a JSFunction that wraps a native function that
+// forwards the call to the original 'callable'.
+class FunctionForwarderOptions;
+bool
+NewFunctionForwarder(JSContext* cx, JS::HandleId id, JS::HandleObject callable,
+                     FunctionForwarderOptions& options, JS::MutableHandleValue vp);
+
+// Old fashioned xpc error reporter. Try to use JS_ReportError instead.
+nsresult
+ThrowAndFail(nsresult errNum, JSContext* cx, bool* retval);
+
+struct GlobalProperties {
+    GlobalProperties() {
+      mozilla::PodZero(this);
+
+    }
+    bool Parse(JSContext* cx, JS::HandleObject obj);
+    bool DefineInXPCComponents(JSContext* cx, JS::HandleObject obj);
+    bool DefineInSandbox(JSContext* cx, JS::HandleObject obj);
+    bool CSS : 1;
+    bool indexedDB : 1;
+    bool XMLHttpRequest : 1;
+    bool TextDecoder : 1;
+    bool TextEncoder : 1;
+    bool URL : 1;
+    bool URLSearchParams : 1;
+    bool atob : 1;
+    bool btoa : 1;
+    bool Blob : 1;
+    bool Directory : 1;
+    bool File : 1;
+    bool crypto : 1;
+    bool rtcIdentityProvider : 1;
+    bool fetch : 1;
+    bool caches : 1;
+    bool fileReader: 1;
+private:
+    bool Define(JSContext* cx, JS::HandleObject obj);
+};
+
+// Infallible.
+already_AddRefed<nsIXPCComponents_utils_Sandbox>
+NewSandboxConstructor();
+
+// Returns true if class of 'obj' is SandboxClass.
+bool
+IsSandbox(JSObject* obj);
+
+class MOZ_STACK_CLASS OptionsBase {
+public:
+    explicit OptionsBase(JSContext* cx = xpc_GetSafeJSContext(),
+                         JSObject* options = nullptr)
+        : mCx(cx)
+        , mObject(cx, options)
+    { }
+
+    virtual bool Parse() = 0;
+
+protected:
+    bool ParseValue(const char* name, JS::MutableHandleValue prop, bool* found = nullptr);
+    bool ParseBoolean(const char* name, bool* prop);
+    bool ParseObject(const char* name, JS::MutableHandleObject prop);
+    bool ParseJSString(const char* name, JS::MutableHandleString prop);
+    bool ParseString(const char* name, nsCString& prop);
+    bool ParseString(const char* name, nsString& prop);
+    bool ParseId(const char* name, JS::MutableHandleId id);
+    bool ParseUInt32(const char* name, uint32_t* prop);
+
+    JSContext* mCx;
+    JS::RootedObject mObject;
+};
+
+class MOZ_STACK_CLASS SandboxOptions : public OptionsBase {
+public:
+    explicit SandboxOptions(JSContext* cx = xpc_GetSafeJSContext(),
+                            JSObject* options = nullptr)
+        : OptionsBase(cx, options)
+        , wantXrays(true)
+        , allowWaivers(true)
+        , wantComponents(true)
+        , wantExportHelpers(false)
+        , isWebExtensionContentScript(false)
+        , waiveInterposition(false)
+        , proto(cx)
+        , addonId(cx)
+        , writeToGlobalPrototype(false)
+        , sameZoneAs(cx)
+        , freshZone(false)
+        , invisibleToDebugger(false)
+        , discardSource(false)
+        , metadata(cx)
+        , userContextId(0)
+        , originAttributes(cx)
+    { }
+
+    virtual bool Parse();
+
+    bool wantXrays;
+    bool allowWaivers;
+    bool wantComponents;
+    bool wantExportHelpers;
+    bool isWebExtensionContentScript;
+    bool waiveInterposition;
+    JS::RootedObject proto;
+    nsCString sandboxName;
+    JS::RootedString addonId;
+    bool writeToGlobalPrototype;
+    JS::RootedObject sameZoneAs;
+    bool freshZone;
+    bool invisibleToDebugger;
+    bool discardSource;
+    GlobalProperties globalProperties;
+    JS::RootedValue metadata;
+    uint32_t userContextId;
+    JS::RootedObject originAttributes;
+
+protected:
+    bool ParseGlobalProperties();
+};
+
+class MOZ_STACK_CLASS CreateObjectInOptions : public OptionsBase {
+public:
+    explicit CreateObjectInOptions(JSContext* cx = xpc_GetSafeJSContext(),
+                                   JSObject* options = nullptr)
+        : OptionsBase(cx, options)
+        , defineAs(cx, JSID_VOID)
+    { }
+
+    virtual bool Parse() { return ParseId("defineAs", &defineAs); }
+
+    JS::RootedId defineAs;
+};
+
+class MOZ_STACK_CLASS ExportFunctionOptions : public OptionsBase {
+public:
+    explicit ExportFunctionOptions(JSContext* cx = xpc_GetSafeJSContext(),
+                                   JSObject* options = nullptr)
+        : OptionsBase(cx, options)
+        , defineAs(cx, JSID_VOID)
+        , allowCrossOriginArguments(false)
+    { }
+
+    virtual bool Parse() {
+        return ParseId("defineAs", &defineAs) &&
+               ParseBoolean("allowCrossOriginArguments", &allowCrossOriginArguments);
+    }
+
+    JS::RootedId defineAs;
+    bool allowCrossOriginArguments;
+};
+
+class MOZ_STACK_CLASS FunctionForwarderOptions : public OptionsBase {
+public:
+    explicit FunctionForwarderOptions(JSContext* cx = xpc_GetSafeJSContext(),
+                                      JSObject* options = nullptr)
+        : OptionsBase(cx, options)
+        , allowCrossOriginArguments(false)
+    { }
+
+    JSObject* ToJSObject(JSContext* cx) {
+        JS::RootedObject obj(cx, JS_NewObjectWithGivenProto(cx, nullptr, nullptr));
+        if (!obj)
+            return nullptr;
+
+        JS::RootedValue val(cx);
+        unsigned attrs = JSPROP_READONLY | JSPROP_PERMANENT;
+        val = JS::BooleanValue(allowCrossOriginArguments);
+        if (!JS_DefineProperty(cx, obj, "allowCrossOriginArguments", val, attrs))
+            return nullptr;
+
+        return obj;
+    }
+
+    virtual bool Parse() {
+        return ParseBoolean("allowCrossOriginArguments", &allowCrossOriginArguments);
+    }
+
+    bool allowCrossOriginArguments;
+};
+
+class MOZ_STACK_CLASS StackScopedCloneOptions : public OptionsBase {
+public:
+    explicit StackScopedCloneOptions(JSContext* cx = xpc_GetSafeJSContext(),
+                                     JSObject* options = nullptr)
+        : OptionsBase(cx, options)
+        , wrapReflectors(false)
+        , cloneFunctions(false)
+        , deepFreeze(false)
+    { }
+
+    virtual bool Parse() {
+        return ParseBoolean("wrapReflectors", &wrapReflectors) &&
+               ParseBoolean("cloneFunctions", &cloneFunctions) &&
+               ParseBoolean("deepFreeze", &deepFreeze);
+    }
+
+    // When a reflector is encountered, wrap it rather than aborting the clone.
+    bool wrapReflectors;
+
+    // When a function is encountered, clone it (exportFunction-style) rather than
+    // aborting the clone.
+    bool cloneFunctions;
+
+    // If true, the resulting object is deep-frozen after being cloned.
+    bool deepFreeze;
+};
+
+JSObject*
+CreateGlobalObject(JSContext* cx, const JSClass* clasp, nsIPrincipal* principal,
+                   JS::CompartmentOptions& aOptions);
+
+// Modify the provided compartment options, consistent with |aPrincipal| and
+// with globally-cached values of various preferences.
+//
+// Call this function *before* |aOptions| is used to create the corresponding
+// global object, as not all of the options it sets can be modified on an
+// existing global object.  (The type system should make this obvious, because
+// you can't get a *mutable* JS::CompartmentOptions& from an existing global
+// object.)
+void
+InitGlobalObjectOptions(JS::CompartmentOptions& aOptions,
+                        nsIPrincipal* aPrincipal);
+
+// Finish initializing an already-created, not-yet-exposed-to-script global
+// object.  This will attach a Components object (if necessary) and call
+// |JS_FireOnNewGlobalObject| (if necessary).
+//
+// If you must modify compartment options, see InitGlobalObjectOptions above.
+bool
+InitGlobalObject(JSContext* aJSContext, JS::Handle<JSObject*> aGlobal,
+                 uint32_t aFlags);
+
+// Helper for creating a sandbox object to use for evaluating
+// untrusted code completely separated from all other code in the
+// system using EvalInSandbox(). Takes the JSContext on which to
+// do setup etc on, puts the sandbox object in *vp (which must be
+// rooted by the caller), and uses the principal that's either
+// directly passed in prinOrSop or indirectly as an
+// nsIScriptObjectPrincipal holding the principal. If no principal is
+// reachable through prinOrSop, a new null principal will be created
+// and used.
+nsresult
+CreateSandboxObject(JSContext* cx, JS::MutableHandleValue vp, nsISupports* prinOrSop,
+                    xpc::SandboxOptions& options);
+// Helper for evaluating scripts in a sandbox object created with
+// CreateSandboxObject(). The caller is responsible of ensuring
+// that *rval doesn't get collected during the call or usage after the
+// call. This helper will use filename and lineNo for error reporting,
+// and if no filename is provided it will use the codebase from the
+// principal and line number 1 as a fallback.
+nsresult
+EvalInSandbox(JSContext* cx, JS::HandleObject sandbox, const nsAString& source,
+              const nsACString& filename, int32_t lineNo,
+              JSVersion jsVersion, JS::MutableHandleValue rval);
+
+nsresult
+GetSandboxAddonId(JSContext* cx, JS::HandleObject sandboxArg,
+                  JS::MutableHandleValue rval);
+
+// Helper for retrieving metadata stored in a reserved slot. The metadata
+// is set during the sandbox creation using the "metadata" option.
+nsresult
+GetSandboxMetadata(JSContext* cx, JS::HandleObject sandboxArg,
+                   JS::MutableHandleValue rval);
+
+nsresult
+SetSandboxMetadata(JSContext* cx, JS::HandleObject sandboxArg,
+                   JS::HandleValue metadata);
+
+bool
+CreateObjectIn(JSContext* cx, JS::HandleValue vobj, CreateObjectInOptions& options,
+               JS::MutableHandleValue rval);
+
+bool
+EvalInWindow(JSContext* cx, const nsAString& source, JS::HandleObject scope,
+             JS::MutableHandleValue rval);
+
+bool
+ExportFunction(JSContext* cx, JS::HandleValue vscope, JS::HandleValue vfunction,
+               JS::HandleValue voptions, JS::MutableHandleValue rval);
+
+bool
+CloneInto(JSContext* cx, JS::HandleValue vobj, JS::HandleValue vscope,
+          JS::HandleValue voptions, JS::MutableHandleValue rval);
+
+bool
+StackScopedClone(JSContext* cx, StackScopedCloneOptions& options, JS::MutableHandleValue val);
+
+} /* namespace xpc */
+
+
+/***************************************************************************/
+// Inlined utilities.
+
+inline bool
+xpc_ForcePropertyResolve(JSContext* cx, JS::HandleObject obj, jsid id);
+
+inline jsid
+GetJSIDByIndex(JSContext* cx, unsigned index);
+
+namespace xpc {
+
+enum WrapperDenialType {
+    WrapperDenialForXray = 0,
+    WrapperDenialForCOW,
+    WrapperDenialTypeCount
+};
+bool ReportWrapperDenial(JSContext* cx, JS::HandleId id, WrapperDenialType type, const char* reason);
+
+class CompartmentPrivate
+{
+public:
+    enum LocationHint {
+        LocationHintRegular,
+        LocationHintAddon
+    };
+
+    explicit CompartmentPrivate(JSCompartment* c);
+
+    ~CompartmentPrivate();
+
+    static CompartmentPrivate* Get(JSCompartment* compartment)
+    {
+        MOZ_ASSERT(compartment);
+        void* priv = JS_GetCompartmentPrivate(compartment);
+        return static_cast<CompartmentPrivate*>(priv);
+    }
+
+    static CompartmentPrivate* Get(JSObject* object)
+    {
+        JSCompartment* compartment = js::GetObjectCompartment(object);
+        return Get(compartment);
+    }
+
+    // Controls whether this compartment gets Xrays to same-origin. This behavior
+    // is deprecated, but is still the default for sandboxes for compatibity
+    // reasons.
+    bool wantXrays;
+
+    // Controls whether this compartment is allowed to waive Xrays to content
+    // that it subsumes. This should generally be true, except in cases where we
+    // want to prevent code from depending on Xray Waivers (which might make it
+    // more portable to other browser architectures).
+    bool allowWaivers;
+
+    // This flag is intended for a very specific use, internal to Gecko. It may
+    // go away or change behavior at any time. It should not be added to any
+    // documentation and it should not be used without consulting the XPConnect
+    // module owner.
+    bool writeToGlobalPrototype;
+
+    // When writeToGlobalPrototype is true, we use this flag to temporarily
+    // disable the writeToGlobalPrototype behavior (when resolving standard
+    // classes, for example).
+    bool skipWriteToGlobalPrototype;
+
+    // This scope corresponds to a WebExtension content script, and receives
+    // various bits of special compatibility behavior.
+    bool isWebExtensionContentScript;
+
+    // Even if an add-on needs interposition, it does not necessary need it
+    // for every scope. If this flag is set we waive interposition for this
+    // scope.
+    bool waiveInterposition;
+
+    // If CPOWs are disabled for browser code via the
+    // dom.ipc.cpows.forbid-unsafe-from-browser preferences, then only
+    // add-ons can use CPOWs. This flag allows a non-addon scope
+    // to opt into CPOWs. It's necessary for the implementation of
+    // RemoteAddonsParent.jsm.
+    bool allowCPOWs;
+
+    // This is only ever set during mochitest runs when enablePrivilege is called.
+    // It's intended as a temporary stopgap measure until we can finish ripping out
+    // enablePrivilege. Once set, this value is never unset (i.e., it doesn't follow
+    // the old scoping rules of enablePrivilege).
+    //
+    // Using it in production is inherently unsafe.
+    bool universalXPConnectEnabled;
+
+    // This is only ever set during mochitest runs when enablePrivilege is called.
+    // It allows the SpecialPowers scope to waive the normal chrome security
+    // wrappers and expose properties directly to content. This lets us avoid a
+    // bunch of overhead and complexity in our SpecialPowers automation glue.
+    //
+    // Using it in production is inherently unsafe.
+    bool forcePermissiveCOWs;
+
+    // Whether we've emitted a warning about a property that was filtered out
+    // by a security wrapper. See XrayWrapper.cpp.
+    bool wrapperDenialWarnings[WrapperDenialTypeCount];
+
+    // The scriptability of this compartment.
+    Scriptability scriptability;
+
+    // Our XPCWrappedNativeScope. This is non-null if and only if this is an
+    // XPConnect compartment.
+    XPCWrappedNativeScope* scope;
+
+    const nsACString& GetLocation() {
+        if (location.IsEmpty() && locationURI) {
+
+            nsCOMPtr<nsIXPConnectWrappedJS> jsLocationURI =
+                 do_QueryInterface(locationURI);
+            if (jsLocationURI) {
+                // We cannot call into JS-implemented nsIURI objects, because
+                // we are iterating over the JS heap at this point.
+                location =
+                    NS_LITERAL_CSTRING("<JS-implemented nsIURI location>");
+            } else if (NS_FAILED(locationURI->GetSpec(location))) {
+                location = NS_LITERAL_CSTRING("<unknown location>");
+            }
+        }
+        return location;
+    }
+    bool GetLocationURI(nsIURI** aURI) {
+        return GetLocationURI(LocationHintRegular, aURI);
+    }
+    bool GetLocationURI(LocationHint aLocationHint, nsIURI** aURI) {
+        if (locationURI) {
+            nsCOMPtr<nsIURI> rval = locationURI;
+            rval.forget(aURI);
+            return true;
+        }
+        return TryParseLocationURI(aLocationHint, aURI);
+    }
+    void SetLocation(const nsACString& aLocation) {
+        if (aLocation.IsEmpty())
+            return;
+        if (!location.IsEmpty() || locationURI)
+            return;
+        location = aLocation;
+    }
+    void SetLocationURI(nsIURI* aLocationURI) {
+        if (!aLocationURI)
+            return;
+        if (locationURI)
+            return;
+        locationURI = aLocationURI;
+    }
+
+    JSObject2WrappedJSMap* GetWrappedJSMap() const { return mWrappedJSMap; }
+    void UpdateWeakPointersAfterGC(XPCJSContext* context);
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);
+
+private:
+    nsCString location;
+    nsCOMPtr<nsIURI> locationURI;
+    JSObject2WrappedJSMap* mWrappedJSMap;
+
+    bool TryParseLocationURI(LocationHint aType, nsIURI** aURI);
+};
+
+bool IsUniversalXPConnectEnabled(JSCompartment* compartment);
+bool IsUniversalXPConnectEnabled(JSContext* cx);
+bool EnableUniversalXPConnect(JSContext* cx);
+
+inline void
+CrashIfNotInAutomation()
+{
+    MOZ_RELEASE_ASSERT(IsInAutomation());
+}
+
+inline XPCWrappedNativeScope*
+ObjectScope(JSObject* obj)
+{
+    return CompartmentPrivate::Get(obj)->scope;
+}
+
+JSObject* NewOutObject(JSContext* cx);
+bool IsOutObject(JSContext* cx, JSObject* obj);
+
+nsresult HasInstance(JSContext* cx, JS::HandleObject objArg, const nsID* iid, bool* bp);
+
+nsIPrincipal* GetObjectPrincipal(JSObject* obj);
+
+} // namespace xpc
+
+namespace mozilla {
+namespace dom {
+extern bool
+DefineStaticJSVals(JSContext* cx);
+} // namespace dom
+} // namespace mozilla
+
+bool
+xpc_LocalizeContext(JSContext* cx);
+void
+xpc_DelocalizeContext(JSContext* cx);
+
+/***************************************************************************/
+// Inlines use the above - include last.
+
+#include "XPCInlines.h"
+
+/***************************************************************************/
+// Maps have inlines that use the above - include last.
+
+#include "XPCMaps.h"
+
+/***************************************************************************/
+
+#endif /* xpcprivate_h___ */
diff --git a/js/xpconnect/src/xpcpublic.h b/js/xpconnect/src/xpcpublic.h
new file mode 100644
index 000000000..fc8670d46
--- /dev/null
+++ b/js/xpconnect/src/xpcpublic.h
@@ -0,0 +1,635 @@
+/* -*- 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/. */
+
+#ifndef xpcpublic_h
+#define xpcpublic_h
+
+#include "jsapi.h"
+#include "js/HeapAPI.h"
+#include "js/GCAPI.h"
+#include "js/Proxy.h"
+
+#include "nsISupports.h"
+#include "nsIURI.h"
+#include "nsIPrincipal.h"
+#include "nsIGlobalObject.h"
+#include "nsPIDOMWindow.h"
+#include "nsWrapperCache.h"
+#include "nsStringGlue.h"
+#include "nsTArray.h"
+#include "mozilla/dom/JSSlots.h"
+#include "mozilla/fallible.h"
+#include "nsMathUtils.h"
+#include "nsStringBuffer.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/Preferences.h"
+
+class nsGlobalWindow;
+class nsIPrincipal;
+class nsScriptNameSpaceManager;
+class nsIMemoryReporterCallback;
+
+namespace mozilla {
+namespace dom {
+class Exception;
+}
+}
+
+typedef void (* xpcGCCallback)(JSGCStatus status);
+
+namespace xpc {
+
+class Scriptability {
+public:
+    explicit Scriptability(JSCompartment* c);
+    bool Allowed();
+    bool IsImmuneToScriptPolicy();
+
+    void Block();
+    void Unblock();
+    void SetDocShellAllowsScript(bool aAllowed);
+
+    static Scriptability& Get(JSObject* aScope);
+
+private:
+    // Whenever a consumer wishes to prevent script from running on a global,
+    // it increments this value with a call to Block(). When it wishes to
+    // re-enable it (if ever), it decrements this value with a call to Unblock().
+    // Script may not run if this value is non-zero.
+    uint32_t mScriptBlocks;
+
+    // Whether the docshell allows javascript in this scope. If this scope
+    // doesn't have a docshell, this value is always true.
+    bool mDocShellAllowsScript;
+
+    // Whether this scope is immune to user-defined or addon-defined script
+    // policy.
+    bool mImmuneToScriptPolicy;
+
+    // Whether the new-style domain policy when this compartment was created
+    // forbids script execution.
+    bool mScriptBlockedByPolicy;
+};
+
+JSObject*
+TransplantObject(JSContext* cx, JS::HandleObject origobj, JS::HandleObject target);
+
+bool IsContentXBLScope(JSCompartment* compartment);
+bool IsInContentXBLScope(JSObject* obj);
+
+// Return a raw XBL scope object corresponding to contentScope, which must
+// be an object whose global is a DOM window.
+//
+// The return value is not wrapped into cx->compartment, so be sure to enter
+// its compartment before doing anything meaningful.
+//
+// Also note that XBL scopes are lazily created, so the return-value should be
+// null-checked unless the caller can ensure that the scope must already
+// exist.
+//
+// This function asserts if |contentScope| is itself in an XBL scope to catch
+// sloppy consumers. Conversely, GetXBLScopeOrGlobal will handle objects that
+// are in XBL scope (by just returning the global).
+JSObject*
+GetXBLScope(JSContext* cx, JSObject* contentScope);
+
+inline JSObject*
+GetXBLScopeOrGlobal(JSContext* cx, JSObject* obj)
+{
+    if (IsInContentXBLScope(obj))
+        return js::GetGlobalForObjectCrossCompartment(obj);
+    return GetXBLScope(cx, obj);
+}
+
+// This function is similar to GetXBLScopeOrGlobal. However, if |obj| is a
+// chrome scope, then it will return an add-on scope if addonId is non-null.
+// Like GetXBLScopeOrGlobal, it returns the scope of |obj| if it's already a
+// content XBL scope. But it asserts that |obj| is not an add-on scope.
+JSObject*
+GetScopeForXBLExecution(JSContext* cx, JS::HandleObject obj, JSAddonId* addonId);
+
+// Returns whether XBL scopes have been explicitly disabled for code running
+// in this compartment. See the comment around mAllowContentXBLScope.
+bool
+AllowContentXBLScope(JSCompartment* c);
+
+// Returns whether we will use an XBL scope for this compartment. This is
+// semantically equivalent to comparing global != GetXBLScope(global), but it
+// does not have the side-effect of eagerly creating the XBL scope if it does
+// not already exist.
+bool
+UseContentXBLScope(JSCompartment* c);
+
+// Clear out the content XBL scope (if any) on the given global.  This will
+// force creation of a new one if one is needed again.
+void
+ClearContentXBLScope(JSObject* global);
+
+bool
+IsInAddonScope(JSObject* obj);
+
+JSObject*
+GetAddonScope(JSContext* cx, JS::HandleObject contentScope, JSAddonId* addonId);
+
+bool
+IsSandboxPrototypeProxy(JSObject* obj);
+
+bool
+IsReflector(JSObject* obj);
+
+bool
+IsXrayWrapper(JSObject* obj);
+
+// If this function was created for a given XrayWrapper, returns the global of
+// the Xrayed object. Otherwise, returns the global of the function.
+//
+// To emphasize the obvious: the return value here is not necessarily same-
+// compartment with the argument.
+JSObject*
+XrayAwareCalleeGlobal(JSObject* fun);
+
+void
+TraceXPCGlobal(JSTracer* trc, JSObject* obj);
+
+} /* namespace xpc */
+
+namespace JS {
+
+struct RuntimeStats;
+
+} // namespace JS
+
+#define XPC_WRAPPER_FLAGS (JSCLASS_HAS_PRIVATE | JSCLASS_FOREGROUND_FINALIZE)
+
+#define XPCONNECT_GLOBAL_FLAGS_WITH_EXTRA_SLOTS(n)                            \
+    JSCLASS_DOM_GLOBAL | JSCLASS_HAS_PRIVATE |                                \
+    JSCLASS_PRIVATE_IS_NSISUPPORTS |                                          \
+    JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(DOM_GLOBAL_SLOTS + n)
+
+#define XPCONNECT_GLOBAL_EXTRA_SLOT_OFFSET (JSCLASS_GLOBAL_SLOT_COUNT + DOM_GLOBAL_SLOTS)
+
+#define XPCONNECT_GLOBAL_FLAGS XPCONNECT_GLOBAL_FLAGS_WITH_EXTRA_SLOTS(0)
+
+inline JSObject*
+xpc_FastGetCachedWrapper(JSContext* cx, nsWrapperCache* cache, JS::MutableHandleValue vp)
+{
+    if (cache) {
+        JSObject* wrapper = cache->GetWrapper();
+        if (wrapper &&
+            js::GetObjectCompartment(wrapper) == js::GetContextCompartment(cx))
+        {
+            vp.setObject(*wrapper);
+            return wrapper;
+        }
+    }
+
+    return nullptr;
+}
+
+// If aVariant is an XPCVariant, this marks the object to be in aGeneration.
+// This also unmarks the gray JSObject.
+extern void
+xpc_MarkInCCGeneration(nsISupports* aVariant, uint32_t aGeneration);
+
+// If aWrappedJS is a JS wrapper, unmark its JSObject.
+extern void
+xpc_TryUnmarkWrappedGrayObject(nsISupports* aWrappedJS);
+
+extern void
+xpc_UnmarkSkippableJSHolders();
+
+// readable string conversions, static methods and members only
+class XPCStringConvert
+{
+    // One-slot cache, because it turns out it's common for web pages to
+    // get the same string a few times in a row.  We get about a 40% cache
+    // hit rate on this cache last it was measured.  We'd get about 70%
+    // hit rate with a hashtable with removal on finalization, but that
+    // would take a lot more machinery.
+    struct ZoneStringCache
+    {
+        // mString owns mBuffer.  mString is a JS thing, so it can only die
+        // during GC, though it can drop its ref to the buffer if it gets
+        // flattened and wasn't null-terminated.  We clear mString and mBuffer
+        // during GC and in our finalizer (to catch the flatterning case).  As
+        // long as the above holds, mBuffer should not be a dangling pointer, so
+        // using this as a cache key should be safe.
+        //
+        // We also need to include the string's length in the cache key, because
+        // now that we allow non-null-terminated buffers we can have two strings
+        // with the same mBuffer but different lengths.
+        void* mBuffer = nullptr;
+        uint32_t mLength = 0;
+        JSString* mString = nullptr;
+    };
+
+public:
+
+    // If the string shares the readable's buffer, that buffer will
+    // get assigned to *sharedBuffer.  Otherwise null will be
+    // assigned.
+    static bool ReadableToJSVal(JSContext* cx, const nsAString& readable,
+                                nsStringBuffer** sharedBuffer,
+                                JS::MutableHandleValue vp);
+
+    // Convert the given stringbuffer/length pair to a jsval
+    static MOZ_ALWAYS_INLINE bool
+    StringBufferToJSVal(JSContext* cx, nsStringBuffer* buf, uint32_t length,
+                        JS::MutableHandleValue rval, bool* sharedBuffer)
+    {
+        JS::Zone* zone = js::GetContextZone(cx);
+        ZoneStringCache* cache = static_cast<ZoneStringCache*>(JS_GetZoneUserData(zone));
+        if (cache && buf == cache->mBuffer && length == cache->mLength) {
+            MOZ_ASSERT(JS::GetStringZone(cache->mString) == zone);
+            JS::MarkStringAsLive(zone, cache->mString);
+            rval.setString(cache->mString);
+            *sharedBuffer = false;
+            return true;
+        }
+
+        JSString* str = JS_NewExternalString(cx,
+                                             static_cast<char16_t*>(buf->Data()),
+                                             length, &sDOMStringFinalizer);
+        if (!str) {
+            return false;
+        }
+        rval.setString(str);
+        if (!cache) {
+            cache = new ZoneStringCache();
+            JS_SetZoneUserData(zone, cache);
+        }
+        cache->mBuffer = buf;
+        cache->mLength = length;
+        cache->mString = str;
+        *sharedBuffer = true;
+        return true;
+    }
+
+    static void FreeZoneCache(JS::Zone* zone);
+    static void ClearZoneCache(JS::Zone* zone);
+
+    static MOZ_ALWAYS_INLINE bool IsLiteral(JSString* str)
+    {
+        return JS_IsExternalString(str) &&
+               JS_GetExternalStringFinalizer(str) == &sLiteralFinalizer;
+    }
+
+    static MOZ_ALWAYS_INLINE bool IsDOMString(JSString* str)
+    {
+        return JS_IsExternalString(str) &&
+               JS_GetExternalStringFinalizer(str) == &sDOMStringFinalizer;
+    }
+
+private:
+    static const JSStringFinalizer sLiteralFinalizer, sDOMStringFinalizer;
+
+    static void FinalizeLiteral(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars);
+
+    static void FinalizeDOMString(JS::Zone* zone, const JSStringFinalizer* fin, char16_t* chars);
+
+    XPCStringConvert() = delete;
+};
+
+class nsIAddonInterposition;
+
+namespace xpc {
+
+// If these functions return false, then an exception will be set on cx.
+bool Base64Encode(JSContext* cx, JS::HandleValue val, JS::MutableHandleValue out);
+bool Base64Decode(JSContext* cx, JS::HandleValue val, JS::MutableHandleValue out);
+
+/**
+ * Convert an nsString to jsval, returning true on success.
+ * Note, the ownership of the string buffer may be moved from str to rval.
+ * If that happens, str will point to an empty string after this call.
+ */
+bool NonVoidStringToJsval(JSContext* cx, nsAString& str, JS::MutableHandleValue rval);
+inline bool StringToJsval(JSContext* cx, nsAString& str, JS::MutableHandleValue rval)
+{
+    // From the T_DOMSTRING case in XPCConvert::NativeData2JS.
+    if (str.IsVoid()) {
+        rval.setNull();
+        return true;
+    }
+    return NonVoidStringToJsval(cx, str, rval);
+}
+
+inline bool
+NonVoidStringToJsval(JSContext* cx, const nsAString& str, JS::MutableHandleValue rval)
+{
+    nsString mutableCopy;
+    if (!mutableCopy.Assign(str, mozilla::fallible)) {
+        JS_ReportOutOfMemory(cx);
+        return false;
+    }
+    return NonVoidStringToJsval(cx, mutableCopy, rval);
+}
+
+inline bool
+StringToJsval(JSContext* cx, const nsAString& str, JS::MutableHandleValue rval)
+{
+    nsString mutableCopy;
+    if (!mutableCopy.Assign(str, mozilla::fallible)) {
+        JS_ReportOutOfMemory(cx);
+        return false;
+    }
+    return StringToJsval(cx, mutableCopy, rval);
+}
+
+/**
+ * As above, but for mozilla::dom::DOMString.
+ */
+inline
+bool NonVoidStringToJsval(JSContext* cx, mozilla::dom::DOMString& str,
+                          JS::MutableHandleValue rval)
+{
+    if (!str.HasStringBuffer()) {
+        // It's an actual XPCOM string
+        return NonVoidStringToJsval(cx, str.AsAString(), rval);
+    }
+
+    uint32_t length = str.StringBufferLength();
+    if (length == 0) {
+        rval.set(JS_GetEmptyStringValue(cx));
+        return true;
+    }
+
+    nsStringBuffer* buf = str.StringBuffer();
+    bool shared;
+    if (!XPCStringConvert::StringBufferToJSVal(cx, buf, length, rval,
+                                               &shared)) {
+        return false;
+    }
+    if (shared) {
+        // JS now needs to hold a reference to the buffer
+        str.RelinquishBufferOwnership();
+    }
+    return true;
+}
+
+MOZ_ALWAYS_INLINE
+bool StringToJsval(JSContext* cx, mozilla::dom::DOMString& str,
+                   JS::MutableHandleValue rval)
+{
+    if (str.IsNull()) {
+        rval.setNull();
+        return true;
+    }
+    return NonVoidStringToJsval(cx, str, rval);
+}
+
+nsIPrincipal* GetCompartmentPrincipal(JSCompartment* compartment);
+
+void SetLocationForGlobal(JSObject* global, const nsACString& location);
+void SetLocationForGlobal(JSObject* global, nsIURI* locationURI);
+
+// ReportJSRuntimeExplicitTreeStats will expect this in the |extra| member
+// of JS::ZoneStats.
+class ZoneStatsExtras {
+public:
+    ZoneStatsExtras() {}
+
+    nsCString pathPrefix;
+
+private:
+    ZoneStatsExtras(const ZoneStatsExtras& other) = delete;
+    ZoneStatsExtras& operator=(const ZoneStatsExtras& other) = delete;
+};
+
+// ReportJSRuntimeExplicitTreeStats will expect this in the |extra| member
+// of JS::CompartmentStats.
+class CompartmentStatsExtras {
+public:
+    CompartmentStatsExtras() {}
+
+    nsCString jsPathPrefix;
+    nsCString domPathPrefix;
+    nsCOMPtr<nsIURI> location;
+
+private:
+    CompartmentStatsExtras(const CompartmentStatsExtras& other) = delete;
+    CompartmentStatsExtras& operator=(const CompartmentStatsExtras& other) = delete;
+};
+
+// This reports all the stats in |rtStats| that belong in the "explicit" tree,
+// (which isn't all of them).
+// @see ZoneStatsExtras
+// @see CompartmentStatsExtras
+void
+ReportJSRuntimeExplicitTreeStats(const JS::RuntimeStats& rtStats,
+                                 const nsACString& rtPath,
+                                 nsIMemoryReporterCallback* handleReport,
+                                 nsISupports* data,
+                                 bool anonymize,
+                                 size_t* rtTotal = nullptr);
+
+/**
+ * Throws an exception on cx and returns false.
+ */
+bool
+Throw(JSContext* cx, nsresult rv);
+
+/**
+ * Returns the nsISupports native behind a given reflector (either DOM or
+ * XPCWN).
+ */
+already_AddRefed<nsISupports>
+UnwrapReflectorToISupports(JSObject* reflector);
+
+/**
+ * Singleton scopes for stuff that really doesn't fit anywhere else.
+ *
+ * If you find yourself wanting to use these compartments, you're probably doing
+ * something wrong. Callers MUST consult with the XPConnect module owner before
+ * using this compartment. If you don't, bholley will hunt you down.
+ */
+JSObject*
+UnprivilegedJunkScope();
+
+JSObject*
+PrivilegedJunkScope();
+
+/**
+ * Shared compilation scope for XUL prototype documents and XBL
+ * precompilation. This compartment has a null principal. No code may run, and
+ * it is invisible to the debugger.
+ */
+JSObject*
+CompilationScope();
+
+/**
+ * Returns the nsIGlobalObject corresponding to |aObj|'s JS global.
+ */
+nsIGlobalObject*
+NativeGlobal(JSObject* aObj);
+
+/**
+ * If |aObj| is a window, returns the associated nsGlobalWindow.
+ * Otherwise, returns null.
+ */
+nsGlobalWindow*
+WindowOrNull(JSObject* aObj);
+
+/**
+ * If |aObj| has a window for a global, returns the associated nsGlobalWindow.
+ * Otherwise, returns null.
+ */
+nsGlobalWindow*
+WindowGlobalOrNull(JSObject* aObj);
+
+/**
+ * If |aObj| is in an addon scope and that addon scope is associated with a
+ * live DOM Window, returns the associated nsGlobalWindow. Otherwise, returns
+ * null.
+ */
+nsGlobalWindow*
+AddonWindowOrNull(JSObject* aObj);
+
+/**
+ * If |cx| is in a compartment whose global is a window, returns the associated
+ * nsGlobalWindow. Otherwise, returns null.
+ */
+nsGlobalWindow*
+CurrentWindowOrNull(JSContext* cx);
+
+void
+SimulateActivityCallback(bool aActive);
+
+// This function may be used off-main-thread, in which case it is benignly
+// racey.
+bool
+ShouldDiscardSystemSource();
+
+bool
+SharedMemoryEnabled();
+
+bool
+SetAddonInterposition(const nsACString& addonId, nsIAddonInterposition* interposition);
+
+bool
+AllowCPOWsInAddon(const nsACString& addonId, bool allow);
+
+bool
+ExtraWarningsForSystemJS();
+
+class ErrorReport {
+  public:
+    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ErrorReport);
+
+    ErrorReport() : mWindowID(0)
+                  , mLineNumber(0)
+                  , mColumn(0)
+                  , mFlags(0)
+                  , mIsMuted(false)
+    {}
+
+    void Init(JSErrorReport* aReport, const char* aToStringResult,
+              bool aIsChrome, uint64_t aWindowID);
+    void Init(JSContext* aCx, mozilla::dom::Exception* aException,
+              bool aIsChrome, uint64_t aWindowID);
+    // Log the error report to the console.  Which console will depend on the
+    // window id it was initialized with.
+    void LogToConsole();
+    // Log to console, using the given stack object (which should be a stack of
+    // the sort that JS::CaptureCurrentStack produces).  aStack is allowed to be
+    // null.
+    void LogToConsoleWithStack(JS::HandleObject aStack);
+
+    // Produce an error event message string from the given JSErrorReport.  Note
+    // that this may produce an empty string if aReport doesn't have a
+    // message attached.
+    static void ErrorReportToMessageString(JSErrorReport* aReport,
+                                           nsAString& aString);
+
+  public:
+
+    nsCString mCategory;
+    nsString mErrorMsgName;
+    nsString mErrorMsg;
+    nsString mFileName;
+    nsString mSourceLine;
+    uint64_t mWindowID;
+    uint32_t mLineNumber;
+    uint32_t mColumn;
+    uint32_t mFlags;
+    bool mIsMuted;
+
+  private:
+    ~ErrorReport() {}
+};
+
+void
+DispatchScriptErrorEvent(nsPIDOMWindowInner* win, JS::RootingContext* rootingCx,
+                         xpc::ErrorReport* xpcReport, JS::Handle<JS::Value> exception);
+
+// Get a stack of the sort that can be passed to
+// xpc::ErrorReport::LogToConsoleWithStack from the given exception value.  Can
+// return null if the exception value doesn't have an associated stack.  The
+// returned stack, if any, may also not be in the same compartment as
+// exceptionValue.
+//
+// The "win" argument passed in here should be the same as the window whose
+// WindowID() is used to initialize the xpc::ErrorReport.  This may be null, of
+// course.  If it's not null, this function may return a null stack object if
+// the window is far enough gone, because in those cases we don't want to have
+// the stack in the console message keeping the window alive.
+JSObject*
+FindExceptionStackForConsoleReport(nsPIDOMWindowInner* win,
+                                   JS::HandleValue exceptionValue);
+
+// Return a name for the compartment.
+// This function makes reasonable efforts to make this name both mostly human-readable
+// and unique. However, there are no guarantees of either property.
+extern void
+GetCurrentCompartmentName(JSContext*, nsCString& name);
+
+void AddGCCallback(xpcGCCallback cb);
+void RemoveGCCallback(xpcGCCallback cb);
+
+inline bool
+AreNonLocalConnectionsDisabled()
+{
+    static int disabledForTest = -1;
+    if (disabledForTest == -1) {
+        char *s = getenv("MOZ_DISABLE_NONLOCAL_CONNECTIONS");
+        if (s) {
+            disabledForTest = *s != '0';
+        } else {
+            disabledForTest = 0;
+        }
+    }
+    return disabledForTest;
+}
+
+inline bool
+IsInAutomation()
+{
+    const char* prefName =
+      "security.turn_off_all_security_so_that_viruses_can_take_over_this_computer";
+    return mozilla::Preferences::GetBool(prefName) &&
+        AreNonLocalConnectionsDisabled();
+}
+
+} // namespace xpc
+
+namespace mozilla {
+namespace dom {
+
+/**
+ * A test for whether WebIDL methods that should only be visible to
+ * chrome or XBL scopes should be exposed.
+ */
+bool IsChromeOrXBL(JSContext* cx, JSObject* /* unused */);
+
+/**
+ * Same as IsChromeOrXBL but can be used in worker threads as well.
+ */
+bool ThreadSafeIsChromeOrXBL(JSContext* cx, JSObject* obj);
+
+} // namespace dom
+} // namespace mozilla
+
+#endif