js/ipc/JavaScriptShared.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sw=2 et tw=80:
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #ifndef mozilla_jsipc_JavaScriptShared_h__
   9 #define mozilla_jsipc_JavaScriptShared_h__
  10
  11 #include "mozilla/HashFunctions.h"
  12 #include "mozilla/dom/DOMTypes.h"
  13 #include "mozilla/jsipc/CrossProcessObjectWrappers.h"
  14 #include "mozilla/jsipc/PJavaScript.h"
  15 #include "mozilla/StaticPrefs_dom.h"
  16 #include "js/GCHashTable.h"
  17 #include "nsJSUtils.h"
  18
  19 namespace mozilla {
  20 namespace jsipc {
  21
  22 class ObjectId {
  23  public:
  24   // Use 47 bits at most, to be safe, since jsval privates are encoded as
  25   // doubles. See bug 1065811 comment 12 for an explanation.
  26   static const size_t SERIAL_NUMBER_BITS = 47;
  27   static const size_t FLAG_BITS = 1;
  28   static const uint64_t SERIAL_NUMBER_MAX =
  29       (uint64_t(1) << SERIAL_NUMBER_BITS) - 1;
  30
  31   explicit ObjectId(uint64_t serialNumber, bool hasXrayWaiver)
  32       : serialNumber_(serialNumber), hasXrayWaiver_(hasXrayWaiver) {
  33     if (isInvalidSerialNumber(serialNumber)) {
  34       MOZ_CRASH("Bad CPOW Id");
  35     }
  36   }
  37
  38   bool operator==(const ObjectId& other) const {
  39     bool equal = serialNumber() == other.serialNumber();
  40     MOZ_ASSERT_IF(equal, hasXrayWaiver() == other.hasXrayWaiver());
  41     return equal;
  42   }
  43
  44   bool isNull() { return !serialNumber_; }
  45
  46   uint64_t serialNumber() const { return serialNumber_; }
  47   bool hasXrayWaiver() const { return hasXrayWaiver_; }
  48   uint64_t serialize() const {
  49     MOZ_ASSERT(serialNumber(), "Don't send a null ObjectId over IPC");
  50     return uint64_t((serialNumber() << FLAG_BITS) |
  51                     ((hasXrayWaiver() ? 1 : 0) << 0));
  52   }
  53
  54   static ObjectId nullId() { return ObjectId(); }
  55   static Maybe<ObjectId> deserialize(uint64_t data) {
  56     if (isInvalidSerialNumber(data >> FLAG_BITS)) {
  57       return Nothing();
  58     }
  59     return Some(ObjectId(data >> FLAG_BITS, data & 1));
  60   }
  61
  62   // For use with StructGCPolicy.
  63   void trace(JSTracer*) const {}
  64   bool needsSweep() const { return false; }
  65
  66  private:
  67   ObjectId() : serialNumber_(0), hasXrayWaiver_(false) {}
  68
  69   static bool isInvalidSerialNumber(uint64_t aSerialNumber) {
  70     return aSerialNumber == 0 || aSerialNumber > SERIAL_NUMBER_MAX;
  71   }
  72
  73   uint64_t serialNumber_ : SERIAL_NUMBER_BITS;
  74   bool hasXrayWaiver_ : 1;
  75 };
  76
  77 class JavaScriptShared;
  78
  79 // DefaultHasher<T> requires that T coerce to an integral type. We could make
  80 // ObjectId do that, but doing so would weaken our type invariants, so we just
  81 // reimplement it manually.
  82 struct ObjectIdHasher {
  83   typedef ObjectId Lookup;
  84   static js::HashNumber hash(const Lookup& l) {
  85     return mozilla::HashGeneric(l.serialize());
  86   }
  87   static bool match(const ObjectId& k, const ObjectId& l) { return k == l; }
  88   static void rekey(ObjectId& k, const ObjectId& newKey) { k = newKey; }
  89 };
  90
  91 // Map ids -> JSObjects
  92 class IdToObjectMap {
  93   typedef js::HashMap<ObjectId, JS::Heap<JSObject*>, ObjectIdHasher,
  94                       js::SystemAllocPolicy>
  95       Table;
  96
  97  public:
  98   IdToObjectMap();
  99
 100   void trace(JSTracer* trc, uint64_t minimumId = 0);
 101   void sweep();
 102
 103   bool add(ObjectId id, JSObject* obj);
 104   JSObject* find(ObjectId id);
 105   JSObject* findPreserveColor(ObjectId id);
 106   void remove(ObjectId id);
 107
 108   void clear();
 109   bool empty() const;
 110
 111 #ifdef DEBUG
 112   bool has(const ObjectId& id, const JSObject* obj) const;
 113 #endif
 114
 115  private:
 116   Table table_;
 117 };
 118
 119 // Map JSObjects -> ids
 120 class ObjectToIdMap {
 121   using Hasher = js::MovableCellHasher<JS::Heap<JSObject*>>;
 122   using Table = JS::GCHashMap<JS::Heap<JSObject*>, ObjectId, Hasher,
 123                               js::SystemAllocPolicy>;
 124
 125  public:
 126   ObjectToIdMap();
 127
 128   void trace(JSTracer* trc);
 129   void sweep();
 130
 131   bool add(JSContext* cx, JSObject* obj, ObjectId id);
 132   ObjectId find(JSObject* obj);
 133   void remove(JSObject* obj);
 134   void clear();
 135
 136  private:
 137   Table table_;
 138 };
 139
 140 class Logging;
 141
 142 class JavaScriptShared : public CPOWManager {
 143  public:
 144   JavaScriptShared();
 145   virtual ~JavaScriptShared();
 146
 147   void decref();
 148   void incref();
 149
 150   bool Unwrap(JSContext* cx, const nsTArray<CpowEntry>& aCpows,
 151               JS::MutableHandleObject objp) override;
 152   bool Wrap(JSContext* cx, JS::HandleObject aObj,
 153             nsTArray<CpowEntry>* outCpows) override;
 154
 155  protected:
 156   bool toVariant(JSContext* cx, JS::HandleValue from, JSVariant* to);
 157   bool fromVariant(JSContext* cx, const JSVariant& from,
 158                    JS::MutableHandleValue to);
 159
 160   bool toJSIDVariant(JSContext* cx, JS::HandleId from, JSIDVariant* to);
 161   bool fromJSIDVariant(JSContext* cx, const JSIDVariant& from,
 162                        JS::MutableHandleId to);
 163
 164   bool toSymbolVariant(JSContext* cx, JS::Symbol* sym, SymbolVariant* symVarp);
 165   JS::Symbol* fromSymbolVariant(JSContext* cx, const SymbolVariant& symVar);
 166
 167   bool fromDescriptor(JSContext* cx, JS::Handle<JS::PropertyDescriptor> desc,
 168                       PPropertyDescriptor* out);
 169   bool toDescriptor(JSContext* cx, const PPropertyDescriptor& in,
 170                     JS::MutableHandle<JS::PropertyDescriptor> out);
 171
 172   bool toObjectOrNullVariant(JSContext* cx, JSObject* obj,
 173                              ObjectOrNullVariant* objVarp);
 174   JSObject* fromObjectOrNullVariant(JSContext* cx,
 175                                     const ObjectOrNullVariant& objVar);
 176
 177   bool convertIdToGeckoString(JSContext* cx, JS::HandleId id, nsString* to);
 178   bool convertGeckoStringToId(JSContext* cx, const nsString& from,
 179                               JS::MutableHandleId id);
 180
 181   virtual bool toObjectVariant(JSContext* cx, JSObject* obj,
 182                                ObjectVariant* objVarp) = 0;
 183   virtual JSObject* fromObjectVariant(JSContext* cx,
 184                                       const ObjectVariant& objVar) = 0;
 185
 186   static void ConvertID(const nsID& from, JSIID* to);
 187   static void ConvertID(const JSIID& from, nsID* to);
 188
 189   JSObject* findCPOWById(const ObjectId& objId);
 190   JSObject* findCPOWByIdPreserveColor(const ObjectId& objId);
 191   JSObject* findObjectById(JSContext* cx, const ObjectId& objId);
 192
 193 #ifdef DEBUG
 194   bool hasCPOW(const ObjectId& objId, const JSObject* obj) {
 195     MOZ_ASSERT(obj);
 196     return findCPOWByIdPreserveColor(objId) == obj;
 197   }
 198 #endif
 199
 200   static bool LoggingEnabled() {
 201     return sLoggingEnabledByEnvVar || StaticPrefs::dom_ipc_cpows_log_enabled();
 202   }
 203   static bool StackLoggingEnabled() {
 204     return sStackLoggingEnabledByEnvVar ||
 205            StaticPrefs::dom_ipc_cpows_log_stack();
 206   }
 207
 208   friend class Logging;
 209
 210   virtual bool isParent() = 0;
 211
 212   virtual JSObject* scopeForTargetObjects() = 0;
 213
 214  protected:
 215   uintptr_t refcount_;
 216
 217   IdToObjectMap objects_;
 218   IdToObjectMap cpows_;
 219
 220   uint64_t nextSerialNumber_;
 221
 222   // nextCPOWNumber_ should be the value of nextSerialNumber_ in the other
 223   // process. The next new CPOW we get should have this serial number.
 224   uint64_t nextCPOWNumber_;
 225
 226   // CPOW references can be weak, and any object we store in a map may be
 227   // GCed (at which point the CPOW will report itself "dead" to the owner).
 228   // This means that we don't want to store any js::Wrappers in the CPOW map,
 229   // because CPOW will die if the wrapper is GCed, even if the underlying
 230   // object is still alive.
 231   //
 232   // This presents a tricky situation for Xray waivers, since they're normally
 233   // represented as a special same-compartment wrapper. We have to strip them
 234   // off before putting them in the id-to-object and object-to-id maps, so we
 235   // need a way of distinguishing them at lookup-time.
 236   //
 237   // For the id-to-object map, we encode waiver-or-not information into the id
 238   // itself, which lets us do the right thing when accessing the object.
 239   //
 240   // For the object-to-id map, we just keep two maps, one for each type.
 241   ObjectToIdMap unwaivedObjectIds_;
 242   ObjectToIdMap waivedObjectIds_;
 243   ObjectToIdMap& objectIdMap(bool waiver) {
 244     return waiver ? waivedObjectIds_ : unwaivedObjectIds_;
 245   }
 246
 247   static bool sLoggingInitialized;
 248   static bool sLoggingEnabledByEnvVar;
 249   static bool sStackLoggingEnabledByEnvVar;
 250 };
 251
 252 }  // namespace jsipc
 253 }  // namespace mozilla
 254
 255 #endif