js/src/jsapi-tests/testPersistentRooted.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "js/Class.h"
   6 #include "jsapi-tests/tests.h"
   7
   8 using namespace JS;
   9
  10 struct BarkWhenTracedClass {
  11   static int finalizeCount;
  12   static int traceCount;
  13
  14   static const JSClass class_;
  15   static void finalize(JS::GCContext* gcx, JSObject* obj) { finalizeCount++; }
  16   static void trace(JSTracer* trc, JSObject* obj) { traceCount++; }
  17   static void reset() {
  18     finalizeCount = 0;
  19     traceCount = 0;
  20   }
  21 };
  22
  23 int BarkWhenTracedClass::finalizeCount;
  24 int BarkWhenTracedClass::traceCount;
  25
  26 static const JSClassOps BarkWhenTracedClassClassOps = {
  27     nullptr,                        // addProperty
  28     nullptr,                        // delProperty
  29     nullptr,                        // enumerate
  30     nullptr,                        // newEnumerate
  31     nullptr,                        // resolve
  32     nullptr,                        // mayResolve
  33     BarkWhenTracedClass::finalize,  // finalize
  34     nullptr,                        // call
  35     nullptr,                        // construct
  36     BarkWhenTracedClass::trace,     // trace
  37 };
  38
  39 const JSClass BarkWhenTracedClass::class_ = {"BarkWhenTracedClass",
  40                                              JSCLASS_FOREGROUND_FINALIZE,
  41                                              &BarkWhenTracedClassClassOps};
  42
  43 struct Kennel {
  44   PersistentRootedObject obj;
  45   Kennel() {}
  46   explicit Kennel(JSContext* cx) : obj(cx) {}
  47   Kennel(JSContext* cx, const HandleObject& woof) : obj(cx, woof) {}
  48   void init(JSContext* cx, const HandleObject& woof) { obj.init(cx, woof); }
  49   void clear() { obj = nullptr; }
  50 };
  51
  52 // A function for allocating a Kennel and a barker. Only allocating
  53 // PersistentRooteds on the heap, and in this function, helps ensure that the
  54 // conservative GC doesn't find stray references to the barker. Ugh.
  55 MOZ_NEVER_INLINE static Kennel* Allocate(JSContext* cx) {
  56   RootedObject barker(cx, JS_NewObject(cx, &BarkWhenTracedClass::class_));
  57   if (!barker) {
  58     return nullptr;
  59   }
  60
  61   return new Kennel(cx, barker);
  62 }
  63
  64 // Do a GC, expecting |n| barkers to be finalized.
  65 static bool GCFinalizesNBarkers(JSContext* cx, int n) {
  66   int preGCTrace = BarkWhenTracedClass::traceCount;
  67   int preGCFinalize = BarkWhenTracedClass::finalizeCount;
  68
  69   JS_GC(cx);
  70
  71   return (BarkWhenTracedClass::finalizeCount == preGCFinalize + n &&
  72           BarkWhenTracedClass::traceCount > preGCTrace);
  73 }
  74
  75 // PersistentRooted instances protect their contents from being recycled.
  76 BEGIN_TEST(test_PersistentRooted) {
  77   BarkWhenTracedClass::reset();
  78
  79   mozilla::UniquePtr<Kennel> kennel(Allocate(cx));
  80   CHECK(kennel.get());
  81
  82   // GC should be able to find our barker.
  83   CHECK(GCFinalizesNBarkers(cx, 0));
  84
  85   kennel = nullptr;
  86
  87   // Now GC should not be able to find the barker.
  88   JS_GC(cx);
  89   CHECK(BarkWhenTracedClass::finalizeCount == 1);
  90
  91   return true;
  92 }
  93 END_TEST(test_PersistentRooted)
  94
  95 // GC should not be upset by null PersistentRooteds.
  96 BEGIN_TEST(test_PersistentRootedNull) {
  97   BarkWhenTracedClass::reset();
  98
  99   Kennel kennel(cx);
 100   CHECK(!kennel.obj);
 101
 102   JS_GC(cx);
 103   CHECK(BarkWhenTracedClass::finalizeCount == 0);
 104
 105   return true;
 106 }
 107 END_TEST(test_PersistentRootedNull)
 108
 109 // Copy construction works.
 110 BEGIN_TEST(test_PersistentRootedCopy) {
 111   BarkWhenTracedClass::reset();
 112
 113   mozilla::UniquePtr<Kennel> kennel(Allocate(cx));
 114   CHECK(kennel.get());
 115
 116   CHECK(GCFinalizesNBarkers(cx, 0));
 117
 118   // Copy construction! AMAZING!
 119   mozilla::UniquePtr<Kennel> newKennel(new Kennel(*kennel));
 120
 121   CHECK(GCFinalizesNBarkers(cx, 0));
 122
 123   kennel = nullptr;
 124
 125   CHECK(GCFinalizesNBarkers(cx, 0));
 126
 127   newKennel = nullptr;
 128
 129   // Now that kennel and nowKennel are both deallocated, GC should not be
 130   // able to find the barker.
 131   JS_GC(cx);
 132   CHECK(BarkWhenTracedClass::finalizeCount == 1);
 133
 134   return true;
 135 }
 136 END_TEST(test_PersistentRootedCopy)
 137
 138 // Assignment works.
 139 BEGIN_TEST(test_PersistentRootedAssign) {
 140   BarkWhenTracedClass::reset();
 141
 142   mozilla::UniquePtr<Kennel> kennel(Allocate(cx));
 143   CHECK(kennel.get());
 144
 145   CHECK(GCFinalizesNBarkers(cx, 0));
 146
 147   // Allocate a new, empty kennel.
 148   mozilla::UniquePtr<Kennel> kennel2(new Kennel(cx));
 149
 150   // Assignment! ASTONISHING!
 151   *kennel2 = *kennel;
 152
 153   // With both kennels referring to the same barker, it is held alive.
 154   CHECK(GCFinalizesNBarkers(cx, 0));
 155
 156   kennel2 = nullptr;
 157
 158   // The destination of the assignment alone holds the barker alive.
 159   CHECK(GCFinalizesNBarkers(cx, 0));
 160
 161   // Allocate a second barker.
 162   kennel2 = mozilla::UniquePtr<Kennel>(Allocate(cx));
 163   CHECK(kennel2.get());
 164
 165   *kennel = *kennel2;
 166
 167   // Nothing refers to the first kennel any more.
 168   CHECK(GCFinalizesNBarkers(cx, 1));
 169
 170   kennel = nullptr;
 171   kennel2 = nullptr;
 172
 173   // Now that kennel and kennel2 are both deallocated, GC should not be
 174   // able to find the barker.
 175   JS_GC(cx);
 176   CHECK(BarkWhenTracedClass::finalizeCount == 2);
 177
 178   return true;
 179 }
 180 END_TEST(test_PersistentRootedAssign)
 181
 182 static PersistentRootedObject gGlobalRoot;
 183
 184 // PersistentRooted instances can initialized in a separate step to allow for
 185 // global PersistentRooteds.
 186 BEGIN_TEST(test_GlobalPersistentRooted) {
 187   BarkWhenTracedClass::reset();
 188
 189   CHECK(!gGlobalRoot.initialized());
 190
 191   {
 192     RootedObject barker(cx, JS_NewObject(cx, &BarkWhenTracedClass::class_));
 193     CHECK(barker);
 194
 195     gGlobalRoot.init(cx, barker);
 196   }
 197
 198   CHECK(gGlobalRoot.initialized());
 199
 200   // GC should be able to find our barker.
 201   CHECK(GCFinalizesNBarkers(cx, 0));
 202
 203   gGlobalRoot.reset();
 204   CHECK(!gGlobalRoot.initialized());
 205
 206   // Now GC should not be able to find the barker.
 207   JS_GC(cx);
 208   CHECK(BarkWhenTracedClass::finalizeCount == 1);
 209
 210   return true;
 211 }
 212 END_TEST(test_GlobalPersistentRooted)