Add m-esr52 at 52.6.0

1 files changed, 760 insertions, 0 deletions

diff --git a/js/ipc/JavaScriptShared.cpp b/js/ipc/JavaScriptShared.cpp
new file mode 100644
index 000000000..9786243f2
--- /dev/null
+++ b/js/ipc/JavaScriptShared.cpp
@@ -0,0 +1,760 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=4 sw=4 et 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 "JavaScriptShared.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/CPOWManagerGetter.h"
+#include "mozilla/dom/TabChild.h"
+#include "jsfriendapi.h"
+#include "xpcprivate.h"
+#include "WrapperFactory.h"
+#include "mozilla/Preferences.h"
+
+using namespace js;
+using namespace JS;
+using namespace mozilla;
+using namespace mozilla::jsipc;
+
+IdToObjectMap::IdToObjectMap()
+  : table_(SystemAllocPolicy())
+{
+}
+
+bool
+IdToObjectMap::init()
+{
+    if (table_.initialized())
+        return true;
+    return table_.init(32);
+}
+
+void
+IdToObjectMap::trace(JSTracer* trc, uint64_t minimimId)
+{
+    for (Table::Range r(table_.all()); !r.empty(); r.popFront()) {
+        if (r.front().key().serialNumber() >= minimimId)
+            JS::TraceEdge(trc, &r.front().value(), "ipc-object");
+    }
+}
+
+void
+IdToObjectMap::sweep()
+{
+    for (Table::Enum e(table_); !e.empty(); e.popFront()) {
+        JS::Heap<JSObject*>* objp = &e.front().value();
+        JS_UpdateWeakPointerAfterGC(objp);
+        if (!*objp)
+            e.removeFront();
+    }
+}
+
+JSObject*
+IdToObjectMap::find(ObjectId id)
+{
+    Table::Ptr p = table_.lookup(id);
+    if (!p)
+        return nullptr;
+    return p->value();
+}
+
+bool
+IdToObjectMap::add(ObjectId id, JSObject* obj)
+{
+    return table_.put(id, obj);
+}
+
+void
+IdToObjectMap::remove(ObjectId id)
+{
+    table_.remove(id);
+}
+
+void
+IdToObjectMap::clear()
+{
+    table_.clear();
+}
+
+bool
+IdToObjectMap::empty() const
+{
+    return table_.empty();
+}
+
+#ifdef DEBUG
+bool
+IdToObjectMap::has(const ObjectId& id, const JSObject* obj) const
+{
+    auto p = table_.lookup(id);
+    if (!p)
+        return false;
+    return p->value().unbarrieredGet() == obj;
+}
+#endif
+
+bool
+ObjectToIdMap::init()
+{
+    return table_.initialized() || table_.init(32);
+}
+
+void
+ObjectToIdMap::trace(JSTracer* trc)
+{
+    table_.trace(trc);
+}
+
+void
+ObjectToIdMap::sweep()
+{
+    table_.sweep();
+}
+
+ObjectId
+ObjectToIdMap::find(JSObject* obj)
+{
+    Table::Ptr p = table_.lookup(obj);
+    if (!p)
+        return ObjectId::nullId();
+    return p->value();
+}
+
+bool
+ObjectToIdMap::add(JSContext* cx, JSObject* obj, ObjectId id)
+{
+    return table_.put(obj, id);
+}
+
+void
+ObjectToIdMap::remove(JSObject* obj)
+{
+    table_.remove(obj);
+}
+
+void
+ObjectToIdMap::clear()
+{
+    table_.clear();
+}
+
+bool JavaScriptShared::sLoggingInitialized;
+bool JavaScriptShared::sLoggingEnabled;
+bool JavaScriptShared::sStackLoggingEnabled;
+
+JavaScriptShared::JavaScriptShared()
+  : refcount_(1),
+    nextSerialNumber_(1),
+    nextCPOWNumber_(1)
+{
+    if (!sLoggingInitialized) {
+        sLoggingInitialized = true;
+
+        if (PR_GetEnv("MOZ_CPOW_LOG")) {
+            sLoggingEnabled = true;
+            sStackLoggingEnabled = strstr(PR_GetEnv("MOZ_CPOW_LOG"), "stacks");
+        } else {
+            Preferences::AddBoolVarCache(&sLoggingEnabled,
+                                         "dom.ipc.cpows.log.enabled", false);
+            Preferences::AddBoolVarCache(&sStackLoggingEnabled,
+                                         "dom.ipc.cpows.log.stack", false);
+        }
+    }
+}
+
+JavaScriptShared::~JavaScriptShared()
+{
+    MOZ_RELEASE_ASSERT(cpows_.empty());
+}
+
+bool
+JavaScriptShared::init()
+{
+    if (!objects_.init())
+        return false;
+    if (!cpows_.init())
+        return false;
+    if (!unwaivedObjectIds_.init())
+        return false;
+    if (!waivedObjectIds_.init())
+        return false;
+
+    return true;
+}
+
+void
+JavaScriptShared::decref()
+{
+    refcount_--;
+    if (!refcount_)
+        delete this;
+}
+
+void
+JavaScriptShared::incref()
+{
+    refcount_++;
+}
+
+bool
+JavaScriptShared::convertIdToGeckoString(JSContext* cx, JS::HandleId id, nsString* to)
+{
+    RootedValue idval(cx);
+    if (!JS_IdToValue(cx, id, &idval))
+        return false;
+
+    RootedString str(cx, ToString(cx, idval));
+    if (!str)
+        return false;
+
+    return AssignJSString(cx, *to, str);
+}
+
+bool
+JavaScriptShared::convertGeckoStringToId(JSContext* cx, const nsString& from, JS::MutableHandleId to)
+{
+    RootedString str(cx, JS_NewUCStringCopyN(cx, from.BeginReading(), from.Length()));
+    if (!str)
+        return false;
+
+    return JS_StringToId(cx, str, to);
+}
+
+bool
+JavaScriptShared::toVariant(JSContext* cx, JS::HandleValue from, JSVariant* to)
+{
+    switch (JS_TypeOfValue(cx, from)) {
+      case JSTYPE_VOID:
+        *to = UndefinedVariant();
+        return true;
+
+      case JSTYPE_OBJECT:
+      case JSTYPE_FUNCTION:
+      {
+        RootedObject obj(cx, from.toObjectOrNull());
+        if (!obj) {
+            MOZ_ASSERT(from.isNull());
+            *to = NullVariant();
+            return true;
+        }
+
+        if (xpc_JSObjectIsID(cx, obj)) {
+            JSIID iid;
+            const nsID* id = xpc_JSObjectToID(cx, obj);
+            ConvertID(*id, &iid);
+            *to = iid;
+            return true;
+        }
+
+        ObjectVariant objVar;
+        if (!toObjectVariant(cx, obj, &objVar))
+            return false;
+        *to = objVar;
+        return true;
+      }
+
+      case JSTYPE_SYMBOL:
+      {
+        RootedSymbol sym(cx, from.toSymbol());
+
+        SymbolVariant symVar;
+        if (!toSymbolVariant(cx, sym, &symVar))
+            return false;
+        *to = symVar;
+        return true;
+      }
+
+      case JSTYPE_STRING:
+      {
+        nsAutoJSString autoStr;
+        if (!autoStr.init(cx, from))
+            return false;
+        *to = autoStr;
+        return true;
+      }
+
+      case JSTYPE_NUMBER:
+        if (from.isInt32())
+            *to = double(from.toInt32());
+        else
+            *to = from.toDouble();
+        return true;
+
+      case JSTYPE_BOOLEAN:
+        *to = from.toBoolean();
+        return true;
+
+      default:
+        MOZ_ASSERT(false);
+        return false;
+    }
+}
+
+bool
+JavaScriptShared::fromVariant(JSContext* cx, const JSVariant& from, MutableHandleValue to)
+{
+    switch (from.type()) {
+        case JSVariant::TUndefinedVariant:
+          to.set(UndefinedValue());
+          return true;
+
+        case JSVariant::TNullVariant:
+          to.set(NullValue());
+          return true;
+
+        case JSVariant::TObjectVariant:
+        {
+          JSObject* obj = fromObjectVariant(cx, from.get_ObjectVariant());
+          if (!obj)
+              return false;
+          to.set(ObjectValue(*obj));
+          return true;
+        }
+
+        case JSVariant::TSymbolVariant:
+        {
+          Symbol* sym = fromSymbolVariant(cx, from.get_SymbolVariant());
+          if (!sym)
+              return false;
+          to.setSymbol(sym);
+          return true;
+        }
+
+        case JSVariant::Tdouble:
+          to.set(JS_NumberValue(from.get_double()));
+          return true;
+
+        case JSVariant::Tbool:
+          to.setBoolean(from.get_bool());
+          return true;
+
+        case JSVariant::TnsString:
+        {
+          const nsString& old = from.get_nsString();
+          JSString* str = JS_NewUCStringCopyN(cx, old.BeginReading(), old.Length());
+          if (!str)
+              return false;
+          to.set(StringValue(str));
+          return true;
+        }
+
+        case JSVariant::TJSIID:
+        {
+          nsID iid;
+          const JSIID& id = from.get_JSIID();
+          ConvertID(id, &iid);
+
+          JSCompartment* compartment = GetContextCompartment(cx);
+          RootedObject global(cx, JS_GetGlobalForCompartmentOrNull(cx, compartment));
+          JSObject* obj = xpc_NewIDObject(cx, global, iid);
+          if (!obj)
+              return false;
+          to.set(ObjectValue(*obj));
+          return true;
+        }
+
+        default:
+          MOZ_CRASH("NYI");
+          return false;
+    }
+}
+
+bool
+JavaScriptShared::toJSIDVariant(JSContext* cx, HandleId from, JSIDVariant* to)
+{
+    if (JSID_IS_STRING(from)) {
+        nsAutoJSString autoStr;
+        if (!autoStr.init(cx, JSID_TO_STRING(from)))
+            return false;
+        *to = autoStr;
+        return true;
+    }
+    if (JSID_IS_INT(from)) {
+        *to = JSID_TO_INT(from);
+        return true;
+    }
+    if (JSID_IS_SYMBOL(from)) {
+        SymbolVariant symVar;
+        if (!toSymbolVariant(cx, JSID_TO_SYMBOL(from), &symVar))
+            return false;
+        *to = symVar;
+        return true;
+    }
+    MOZ_ASSERT(false);
+    return false;
+}
+
+bool
+JavaScriptShared::fromJSIDVariant(JSContext* cx, const JSIDVariant& from, MutableHandleId to)
+{
+    switch (from.type()) {
+      case JSIDVariant::TSymbolVariant: {
+        Symbol* sym = fromSymbolVariant(cx, from.get_SymbolVariant());
+        if (!sym)
+            return false;
+        to.set(SYMBOL_TO_JSID(sym));
+        return true;
+      }
+
+      case JSIDVariant::TnsString:
+        return convertGeckoStringToId(cx, from.get_nsString(), to);
+
+      case JSIDVariant::Tint32_t:
+        to.set(INT_TO_JSID(from.get_int32_t()));
+        return true;
+
+      default:
+        return false;
+    }
+}
+
+bool
+JavaScriptShared::toSymbolVariant(JSContext* cx, JS::Symbol* symArg, SymbolVariant* symVarp)
+{
+    RootedSymbol sym(cx, symArg);
+    MOZ_ASSERT(sym);
+
+    SymbolCode code = GetSymbolCode(sym);
+    if (static_cast<uint32_t>(code) < WellKnownSymbolLimit) {
+        *symVarp = WellKnownSymbol(static_cast<uint32_t>(code));
+        return true;
+    }
+    if (code == SymbolCode::InSymbolRegistry) {
+        nsAutoJSString autoStr;
+        if (!autoStr.init(cx, GetSymbolDescription(sym)))
+            return false;
+        *symVarp = RegisteredSymbol(autoStr);
+        return true;
+    }
+
+    JS_ReportErrorASCII(cx, "unique symbol can't be used with CPOW");
+    return false;
+}
+
+JS::Symbol*
+JavaScriptShared::fromSymbolVariant(JSContext* cx, const SymbolVariant& symVar)
+{
+    switch (symVar.type()) {
+      case SymbolVariant::TWellKnownSymbol: {
+        uint32_t which = symVar.get_WellKnownSymbol().which();
+        if (which < WellKnownSymbolLimit)
+            return GetWellKnownSymbol(cx, static_cast<SymbolCode>(which));
+        MOZ_ASSERT(false, "bad child data");
+        return nullptr;
+      }
+
+      case SymbolVariant::TRegisteredSymbol: {
+        nsString key = symVar.get_RegisteredSymbol().key();
+        RootedString str(cx, JS_NewUCStringCopyN(cx, key.get(), key.Length()));
+        if (!str)
+            return nullptr;
+        return GetSymbolFor(cx, str);
+      }
+
+      default:
+        return nullptr;
+    }
+}
+
+/* static */ void
+JavaScriptShared::ConvertID(const nsID& from, JSIID* to)
+{
+    to->m0() = from.m0;
+    to->m1() = from.m1;
+    to->m2() = from.m2;
+    to->m3_0() = from.m3[0];
+    to->m3_1() = from.m3[1];
+    to->m3_2() = from.m3[2];
+    to->m3_3() = from.m3[3];
+    to->m3_4() = from.m3[4];
+    to->m3_5() = from.m3[5];
+    to->m3_6() = from.m3[6];
+    to->m3_7() = from.m3[7];
+}
+
+/* static */ void
+JavaScriptShared::ConvertID(const JSIID& from, nsID* to)
+{
+    to->m0 = from.m0();
+    to->m1 = from.m1();
+    to->m2 = from.m2();
+    to->m3[0] = from.m3_0();
+    to->m3[1] = from.m3_1();
+    to->m3[2] = from.m3_2();
+    to->m3[3] = from.m3_3();
+    to->m3[4] = from.m3_4();
+    to->m3[5] = from.m3_5();
+    to->m3[6] = from.m3_6();
+    to->m3[7] = from.m3_7();
+}
+
+JSObject*
+JavaScriptShared::findObjectById(JSContext* cx, const ObjectId& objId)
+{
+    RootedObject obj(cx, objects_.find(objId));
+    if (!obj) {
+        JS_ReportErrorASCII(cx, "operation not possible on dead CPOW");
+        return nullptr;
+    }
+
+    // Each process has a dedicated compartment for CPOW targets. All CPOWs
+    // from the other process point to objects in this scope. From there, they
+    // can access objects in other compartments using cross-compartment
+    // wrappers.
+    JSAutoCompartment ac(cx, scopeForTargetObjects());
+    if (objId.hasXrayWaiver()) {
+        {
+            JSAutoCompartment ac2(cx, obj);
+            obj = js::ToWindowProxyIfWindow(obj);
+            MOZ_ASSERT(obj);
+        }
+        if (!xpc::WrapperFactory::WaiveXrayAndWrap(cx, &obj))
+            return nullptr;
+    } else {
+        if (!JS_WrapObject(cx, &obj))
+            return nullptr;
+    }
+    return obj;
+}
+
+static const uint64_t UnknownPropertyOp = 1;
+
+bool
+JavaScriptShared::fromDescriptor(JSContext* cx, Handle<PropertyDescriptor> desc,
+                                 PPropertyDescriptor* out)
+{
+    out->attrs() = desc.attributes();
+    if (!toVariant(cx, desc.value(), &out->value()))
+        return false;
+
+    if (!toObjectOrNullVariant(cx, desc.object(), &out->obj()))
+        return false;
+
+    if (!desc.getter()) {
+        out->getter() = 0;
+    } else if (desc.hasGetterObject()) {
+        JSObject* getter = desc.getterObject();
+        ObjectVariant objVar;
+        if (!toObjectVariant(cx, getter, &objVar))
+            return false;
+        out->getter() = objVar;
+    } else {
+        MOZ_ASSERT(desc.getter() != JS_PropertyStub);
+        out->getter() = UnknownPropertyOp;
+    }
+
+    if (!desc.setter()) {
+        out->setter() = 0;
+    } else if (desc.hasSetterObject()) {
+        JSObject* setter = desc.setterObject();
+        ObjectVariant objVar;
+        if (!toObjectVariant(cx, setter, &objVar))
+            return false;
+        out->setter() = objVar;
+    } else {
+        MOZ_ASSERT(desc.setter() != JS_StrictPropertyStub);
+        out->setter() = UnknownPropertyOp;
+    }
+
+    return true;
+}
+
+bool
+UnknownPropertyStub(JSContext* cx, HandleObject obj, HandleId id, MutableHandleValue vp)
+{
+    JS_ReportErrorASCII(cx, "getter could not be wrapped via CPOWs");
+    return false;
+}
+
+bool
+UnknownStrictPropertyStub(JSContext* cx, HandleObject obj, HandleId id, MutableHandleValue vp,
+                          ObjectOpResult& result)
+{
+    JS_ReportErrorASCII(cx, "setter could not be wrapped via CPOWs");
+    return false;
+}
+
+bool
+JavaScriptShared::toDescriptor(JSContext* cx, const PPropertyDescriptor& in,
+                               MutableHandle<PropertyDescriptor> out)
+{
+    out.setAttributes(in.attrs());
+    if (!fromVariant(cx, in.value(), out.value()))
+        return false;
+    out.object().set(fromObjectOrNullVariant(cx, in.obj()));
+
+    if (in.getter().type() == GetterSetter::Tuint64_t && !in.getter().get_uint64_t()) {
+        out.setGetter(nullptr);
+    } else if (in.attrs() & JSPROP_GETTER) {
+        Rooted<JSObject*> getter(cx);
+        getter = fromObjectVariant(cx, in.getter().get_ObjectVariant());
+        if (!getter)
+            return false;
+        out.setGetter(JS_DATA_TO_FUNC_PTR(JSGetterOp, getter.get()));
+    } else {
+        out.setGetter(UnknownPropertyStub);
+    }
+
+    if (in.setter().type() == GetterSetter::Tuint64_t && !in.setter().get_uint64_t()) {
+        out.setSetter(nullptr);
+    } else if (in.attrs() & JSPROP_SETTER) {
+        Rooted<JSObject*> setter(cx);
+        setter = fromObjectVariant(cx, in.setter().get_ObjectVariant());
+        if (!setter)
+            return false;
+        out.setSetter(JS_DATA_TO_FUNC_PTR(JSSetterOp, setter.get()));
+    } else {
+        out.setSetter(UnknownStrictPropertyStub);
+    }
+
+    return true;
+}
+
+bool
+JavaScriptShared::toObjectOrNullVariant(JSContext* cx, JSObject* obj, ObjectOrNullVariant* objVarp)
+{
+    if (!obj) {
+        *objVarp = NullVariant();
+        return true;
+    }
+
+    ObjectVariant objVar;
+    if (!toObjectVariant(cx, obj, &objVar))
+        return false;
+
+    *objVarp = objVar;
+    return true;
+}
+
+JSObject*
+JavaScriptShared::fromObjectOrNullVariant(JSContext* cx, const ObjectOrNullVariant& objVar)
+{
+    if (objVar.type() == ObjectOrNullVariant::TNullVariant)
+        return nullptr;
+
+    return fromObjectVariant(cx, objVar.get_ObjectVariant());
+}
+
+CrossProcessCpowHolder::CrossProcessCpowHolder(dom::CPOWManagerGetter* managerGetter,
+                                               const InfallibleTArray<CpowEntry>& cpows)
+  : js_(nullptr),
+    cpows_(cpows),
+    unwrapped_(false)
+{
+    // Only instantiate the CPOW manager if we might need it later.
+    if (cpows.Length())
+        js_ = managerGetter->GetCPOWManager();
+}
+
+CrossProcessCpowHolder::~CrossProcessCpowHolder()
+{
+    if (cpows_.Length() && !unwrapped_) {
+        // This should only happen if a message manager message
+        // containing CPOWs gets ignored for some reason. We need to
+        // unwrap every incoming CPOW in this process to ensure that
+        // the corresponding part of the CPOW in the other process
+        // will eventually be collected. The scope for this object
+        // doesn't really matter, because it immediately becomes
+        // garbage.
+        AutoJSAPI jsapi;
+        if (!jsapi.Init(xpc::PrivilegedJunkScope()))
+            return;
+        JSContext* cx = jsapi.cx();
+        JS::Rooted<JSObject*> cpows(cx);
+        js_->Unwrap(cx, cpows_, &cpows);
+    }
+}
+
+bool
+CrossProcessCpowHolder::ToObject(JSContext* cx, JS::MutableHandleObject objp)
+{
+    unwrapped_ = true;
+
+    if (!cpows_.Length())
+        return true;
+
+    return js_->Unwrap(cx, cpows_, objp);
+}
+
+bool
+JavaScriptShared::Unwrap(JSContext* cx, const InfallibleTArray<CpowEntry>& aCpows,
+                         JS::MutableHandleObject objp)
+{
+    objp.set(nullptr);
+
+    if (!aCpows.Length())
+        return true;
+
+    RootedObject obj(cx, JS_NewPlainObject(cx));
+    if (!obj)
+        return false;
+
+    RootedValue v(cx);
+    RootedString str(cx);
+    for (size_t i = 0; i < aCpows.Length(); i++) {
+        const nsString& name = aCpows[i].name();
+
+        if (!fromVariant(cx, aCpows[i].value(), &v))
+            return false;
+
+        if (!JS_DefineUCProperty(cx,
+                                 obj,
+                                 name.BeginReading(),
+                                 name.Length(),
+                                 v,
+                                 JSPROP_ENUMERATE))
+        {
+            return false;
+        }
+    }
+
+    objp.set(obj);
+    return true;
+}
+
+bool
+JavaScriptShared::Wrap(JSContext* cx, HandleObject aObj, InfallibleTArray<CpowEntry>* outCpows)
+{
+    if (!aObj)
+        return true;
+
+    Rooted<IdVector> ids(cx, IdVector(cx));
+    if (!JS_Enumerate(cx, aObj, &ids))
+        return false;
+
+    RootedId id(cx);
+    RootedValue v(cx);
+    for (size_t i = 0; i < ids.length(); i++) {
+        id = ids[i];
+
+        nsString str;
+        if (!convertIdToGeckoString(cx, id, &str))
+            return false;
+
+        if (!JS_GetPropertyById(cx, aObj, id, &v))
+            return false;
+
+        JSVariant var;
+        if (!toVariant(cx, v, &var))
+            return false;
+
+        outCpows->AppendElement(CpowEntry(str, var));
+    }
+
+    return true;
+}
+
+CPOWManager*
+mozilla::jsipc::CPOWManagerFor(PJavaScriptParent* aParent)
+{
+    return static_cast<JavaScriptParent*>(aParent);
+}
+
+CPOWManager*
+mozilla::jsipc::CPOWManagerFor(PJavaScriptChild* aChild)
+{
+    return static_cast<JavaScriptChild*>(aChild);
+}