tor-browser

browser_weak_xpcwjs.js (7932B)

---

/* Any copyright is dedicated to the Public Domain.
  http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

// Some basic tests of the lifetime of an XPCWJS with a weak reference.

// Create a weak reference, with a single-element weak map.
let make_weak_ref = function (obj) {
 let m = new WeakMap();
 m.set(obj, {});
 return m;
};

// Check to see if a weak reference is dead.
let weak_ref_dead = function (r) {
 return !SpecialPowers.nondeterministicGetWeakMapKeys(r).length;
};

add_task(async function gc_wwjs() {
 // This subtest checks that a WJS with only a weak reference to it gets
 // cleaned up, if its JS object is garbage, after just a GC.
 // For the browser, this probably isn't important, but tests seem to rely
 // on it.
 const TEST_PREF = "wjs.pref1";
 let wjs_weak_ref = null;
 let observed_count = 0;

 {
   Services.prefs.clearUserPref(TEST_PREF);

   // Create the observer object.
   let observer1 = {
     QueryInterface: ChromeUtils.generateQI(["nsISupportsWeakReference"]),
     observe() {
       observed_count += 1;
       info(TEST_PREF + " pref observer.");
     },
   };

   // Register the weak observer.
   Services.prefs.addObserver(TEST_PREF, observer1, true);

   // Invoke the observer to make sure it is doing something.
   info("Flipping the pref " + TEST_PREF);
   Services.prefs.setBoolPref(TEST_PREF, true);
   is(observed_count, 1, "Ran observer1 once after first flip.");

   wjs_weak_ref = make_weak_ref(observer1);

   // Exit the scope, making observer1 garbage.
 }

 // Run the GC.
 info("Running the GC.");
 SpecialPowers.forceGC();

 // Flip the pref again to make sure that the observer doesn't run.
 info("Flipping the pref " + TEST_PREF);
 Services.prefs.setBoolPref(TEST_PREF, false);

 is(observed_count, 1, "After GC, don't run the observer.");
 ok(weak_ref_dead(wjs_weak_ref), "WJS with weak ref should be freed.");

 Services.prefs.clearUserPref(TEST_PREF);
});

add_task(async function alive_wwjs() {
 // This subtest checks that a WJS with only a weak reference should not get
 // cleaned up if the underlying JS object is held alive (here, via the
 // variable |observer2|).
 const TEST_PREF = "wjs.pref2";
 let observed_count = 0;

 Services.prefs.clearUserPref(TEST_PREF);
 let observer2 = {
   QueryInterface: ChromeUtils.generateQI(["nsISupportsWeakReference"]),
   observe() {
     observed_count += 1;
     info(TEST_PREF + " pref observer");
   },
 };
 Services.prefs.addObserver(TEST_PREF, observer2, true);

 Services.prefs.setBoolPref(TEST_PREF, true);
 is(observed_count, 1, "Run observer2 once after first flip.");

 await new Promise(resolve =>
   SpecialPowers.exactGC(() => {
     SpecialPowers.forceCC();
     SpecialPowers.forceGC();
     SpecialPowers.forceCC();

     Services.prefs.setBoolPref(TEST_PREF, false);

     is(observed_count, 2, "Run observer2 again after second flip.");

     Services.prefs.removeObserver(TEST_PREF, observer2);
     Services.prefs.clearUserPref(TEST_PREF);

     resolve();
   })
 );
});

add_task(async function cc_wwjs() {
 // This subtest checks that a WJS with only a weak reference to it, where the
 // underlying JS object is part of a garbage cycle, gets cleaned up after a
 // cycle collection. It also checks that things held alive by the JS object
 // don't end up in an unlinked state, although that's mostly for fun, because
 // it is redundant with checking that the JS object gets cleaned up.
 const TEST_PREF = "wjs.pref3";
 let wjs_weak_ref = null;
 let observed_count = 0;
 let canary_count;

 {
   Services.prefs.clearUserPref(TEST_PREF);

   // Set up a canary object that lets us detect unlinking.
   // (When an nsArrayCC is unlinked, all of the elements are removed.)
   // This is needed to distinguish the case where the observer was unlinked
   // without removing the weak reference from the case where we did not
   // collect the observer at all.
   let canary = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
   let someString = Cc["@mozilla.org/supports-string;1"].createInstance(
     Ci.nsISupportsString
   );
   someString.data = "canary";
   canary.appendElement(someString);
   canary.appendElement(someString);
   is(canary.Count(), 2, "The canary array should have two elements");

   // Create the observer object.
   let observer3 = {
     QueryInterface: ChromeUtils.generateQI(["nsISupportsWeakReference"]),
     canary,
     cycle: new DOMMatrix(),
     observe() {
       observed_count += 1;
       canary_count = this.canary.Count();
       info(TEST_PREF + " pref observer. Canary count: " + canary_count);
     },
   };

   // Set up a cycle between C++ and JS that requires the CC to collect.
   // |cycle| is a random WebIDL object that we can set an expando on to
   // create a nice clean cycle that doesn't involve any weird XPConnect stuff.
   observer3.cycle.backEdge = observer3;

   // Register the weak observer.
   Services.prefs.addObserver(TEST_PREF, observer3, true);

   // Invoke the observer to make sure it is doing something.
   info("Flipping the pref " + TEST_PREF);
   canary_count = -1;
   Services.prefs.setBoolPref(TEST_PREF, true);
   is(
     canary_count,
     2,
     "Observer ran with expected value while observer3 is alive."
   );
   is(observed_count, 1, "Ran observer3 once after first flip.");

   wjs_weak_ref = make_weak_ref(observer3);

   // Exit the scope, making observer3 and canary garbage.
 }

 // Run the GC. This is necessary to mark observer3 gray so the CC
 // might consider it to be garbage. This won't free it because it is held
 // alive from C++ (namely the DOMMatrix via its expando).
 info("Running the GC.");
 SpecialPowers.forceGC();

 // Note: Don't flip the pref here. Doing so will run the observer, which will
 // cause it to get marked black again, preventing it from being freed.
 // For the same reason, don't call weak_ref_dead(wjs_weak_ref) here.

 // Run the CC. This should detect that the cycle between observer3 and the
 // DOMMatrix is garbage, unlinking the DOMMatrix and the canary. Also, the
 // weak reference for the WJS for observer3 should get cleared because the
 // underlying JS object has been identifed as garbage. You can add logging to
 // nsArrayCC's unlink method to see the canary getting unlinked.
 info("Running the CC.");
 SpecialPowers.forceCC();

 // Flip the pref again to make sure that the observer doesn't run.
 info("Flipping the pref " + TEST_PREF);
 canary_count = -1;
 Services.prefs.setBoolPref(TEST_PREF, false);

 isnot(
   canary_count,
   0,
   "After CC, don't run the observer with an unlinked canary."
 );
 isnot(
   canary_count,
   2,
   "After CC, don't run the observer after it is garbage."
 );
 is(canary_count, -1, "After CC, don't run the observer.");
 is(observed_count, 1, "After CC, don't run the observer.");

 ok(
   !weak_ref_dead(wjs_weak_ref),
   "WJS with weak ref shouldn't be freed by the CC."
 );

 // Now that the CC has identified observer3 as garbage, running the GC again
 // should free it.
 info("Running the GC again.");
 SpecialPowers.forceGC();

 ok(weak_ref_dead(wjs_weak_ref), "WJS with weak ref should be freed.");

 info("Flipping the pref " + TEST_PREF);
 canary_count = -1;
 Services.prefs.setBoolPref(TEST_PREF, true);

 // Note: the original implementation of weak references for WJS fails most of
 // the prior canary_count tests, but passes these.
 isnot(
   canary_count,
   0,
   "After GC, don't run the observer with an unlinked canary."
 );
 isnot(
   canary_count,
   2,
   "After GC, don't run the observer after it is garbage."
 );
 is(canary_count, -1, "After GC, don't run the observer.");
 is(observed_count, 1, "After GC, don't run the observer.");

 Services.prefs.clearUserPref(TEST_PREF);
});