js/xpconnect/tests/chrome/test_weakmaps.xul
author Boris Zbarsky <bzbarsky@mit.edu>
Wed, 08 Nov 2017 00:25:33 -0500
changeset 390706 73352624f35c23e6000cd50d095708d69249f35d
parent 330440 aa9330ed3a0791eea57ddb2e1e08fb38dc924cdd
child 402638 b38d59f71915f78922b46a7c7bc65a48488c45f1
permissions -rw-r--r--
Bug 1415389. Make ChromeUtils a WebIDL namespace. Remove ThreadSafeChromeUtils. r=kmag MozReview-Commit-ID: 9ysAeaBMNVt

<?xml version="1.0"?>
<?xml-stylesheet type="text/css" href="chrome://global/skin"?>
<?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=668855
-->
<window title="Mozilla Bug "
        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>

  <!-- test results are displayed in the html:body -->
  <body xmlns="http://www.w3.org/1999/xhtml">
  <a href="https://bugzilla.mozilla.org/show_bug.cgi?id="
     target="_blank">Mozilla Bug 668855</a>
  </body>

  <!-- test code goes here -->
  <script type="application/javascript">
  <![CDATA[
  /** Test for Bug 668855 **/

  let Cu = Components.utils;
  let Ci = Components.interfaces;

  /* 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 ChromeUtils.nondeterministicGetWeakMapKeys(r).length == 0;
  }

  /* Deterministically grab an arbitrary DOM element. */
  let get_live_dom = function () {
    let elems = document.getElementsByTagName("a");
    return elems[0];
  };


  /* Test case from bug 653248, adapted into a standard test.

  This is a dead cycle involving a DOM edge, so the cycle collector can free it.  Keys and
  values reachable only from XPConnect must be marked gray for this to work, and the cycle collector
  must know the proper structure of the heap.

  */
  let make_gray_loop = function () {
    let map = new WeakMap;
    let div = document.createElement("div");
    let key = {};
    div.setUserData("entrain", {m:map, k:key}, null);
    //div.entrain = {m:map, k:key};  This is not sufficient to cause a leak in Fx9
    map.set(key, div);
    return make_weak_ref(map);
  };

  let weakref = make_gray_loop();


  /* Combinations of live and dead gray maps/keys. */
  let basic_weak_ref = null;
  let basic_map_weak_ref = null;
  let black_map = new WeakMap;
  let black_key = {};

  let basic_unit_tests = function () {
    let live_dom = get_live_dom();
    let dead_dom = document.createElement("div");
    let live_map = new WeakMap;
    let dead_map = new WeakMap;
    let live_key = {};
    let dead_key = {};

    // put the live/dead maps/keys into the appropriate DOM elements
    live_dom.basic_unit_tests = {m:live_map, k:live_key};
    dead_dom.setUserData("hook", {m:dead_map, k:dead_key}, null);
    // dead_dom.hook = {m:dead_map, k:dead_key};

    // Create a dead value, and a weak ref to it.
    // The loop keeps dead_dom alive unless the CC is smart enough to kill it.
    let dead_val = {loop:dead_dom};
    basic_weak_ref = make_weak_ref(dead_val);
    basic_map_weak_ref = make_weak_ref(dead_map);

    // set up the actual entries.  most will die.
    live_map.set(live_key, {my_key:'live_live'});
    live_map.set(dead_key, dead_val);
    live_map.set(black_key, {my_key:'live_black'});

    dead_map.set(live_key, dead_val);
    dead_map.set(dead_key, dead_val);
    dead_map.set(black_key, dead_val);

    black_map.set(live_key, {my_key:'black_live'});
    black_map.set(dead_key, dead_val);
    black_map.set(black_key, {my_key:'black_black'});

  };

  basic_unit_tests();


  let check_basic_unit = function () {
    let live_dom = get_live_dom();
    let live_map = live_dom.basic_unit_tests.m;
    let live_key = live_dom.basic_unit_tests.k;

    // check the dead elements
    ok(weak_ref_dead(basic_weak_ref), "Dead value was kept alive.");
    ok(weak_ref_dead(basic_map_weak_ref), "Dead map was kept alive.");

    // check the live gray map
    is(live_map.get(live_key).my_key, 'live_live',
      "Live key should have the same value in live map.");
    is(live_map.get(black_key).my_key, 'live_black',
      "Black key should have the same value in live map.");
    is(ChromeUtils.nondeterministicGetWeakMapKeys(live_map).length, 2,
      "Live map should have two entries.");

    // check the live black map
    is(black_map.get(live_key).my_key, 'black_live',
      "Live key should have the same value in black map.");
    is(black_map.get(black_key).my_key, 'black_black',
      "Black key should have the same value in black map.");
    is(ChromeUtils.nondeterministicGetWeakMapKeys(black_map).length, 2,
      "Black map should have two entries.");    

  };


  /* live gray chained weak map entries, involving the cycle collector. */
  let chainm = new WeakMap;
  let num_chains = 5;

  let nested_cc_maps = function () {
    let dom = get_live_dom();
    for(let i = 0; i < num_chains; i++) {
      let k = {count:i};
      dom.key = k;
      dom0 = document.createElement("div");
      chainm.set(k, {d:dom0});
      dom = document.createElement("div");
      dom0.appendChild(dom);
    };
  };

  let check_nested_cc_maps = function () {
    let dom = get_live_dom();
    let all_ok = true;
    for(let i = 0; i < num_chains; i++) {
      let k = dom.key;
      all_ok = all_ok && k.count == i;
      dom = chainm.get(k).d.firstChild;
    };
    ok(all_ok, "Count was invalid on a key in chained weak map entries.");    
  };

  nested_cc_maps();


  /* black weak map, chained garbage cycle involving DOM */
  let garbage_map = new WeakMap;

  let chained_garbage_maps = function () {
    let dom0 = document.createElement("div");
    let dom = dom0;
    for(let i = 0; i < num_chains; i++) {
      let k = {};
      dom.key = k;
      let new_dom = document.createElement("div");
      garbage_map.set(k, {val_child:new_dom});
      dom = document.createElement("div");
      new_dom.appendChild(dom);
    };
    // tie the knot
    dom.appendChild(dom0);
  };

  chained_garbage_maps();


  /* black weak map, chained garbage cycle involving DOM, XPCWN keys */
  let wn_garbage_map = new WeakMap;

  let wn_chained_garbage_maps = function () {
    let dom0 = document.createElement("div");
    let dom = dom0;
    for(let i = 0; i < num_chains; i++) {
      let new_dom = document.createElement("div");
      wn_garbage_map.set(dom, {wn_val_child:new_dom});
      dom = document.createElement("div");
      new_dom.appendChild(dom);
    };
    // tie the knot
    dom.appendChild(dom0);
  };

  wn_chained_garbage_maps();


  /* The cycle collector shouldn't remove a live wrapped native key. */

  let wn_live_map = new WeakMap;

  let make_live_map = function () {
    let live = get_live_dom();
    wn_live_map.set(live, {});
    ok(wn_live_map.has(get_live_dom()), "Live map should have live DOM node before GC.");
  }

  make_live_map();

  // We're out of ideas for unpreservable natives, now that just about
  // everything is on webidl, so just don't test those.

  /* set up for running precise GC/CC then checking the results */

  SimpleTest.waitForExplicitFinish();

  Cu.schedulePreciseGC(function () {
    SpecialPowers.DOMWindowUtils.cycleCollect();
    SpecialPowers.DOMWindowUtils.garbageCollect();
    SpecialPowers.DOMWindowUtils.garbageCollect();

    ok(weak_ref_dead(weakref), "Garbage gray cycle should be collected.");

    check_nested_cc_maps();

    is(ChromeUtils.nondeterministicGetWeakMapKeys(garbage_map).length, 0, "Chained garbage weak map entries should not leak.");

    check_basic_unit();

    // fixed by Bug 680937
    is(ChromeUtils.nondeterministicGetWeakMapKeys(wn_garbage_map).length, 0,
       "Chained garbage WN weak map entries should not leak.");

    // fixed by Bug 680937
    is(ChromeUtils.nondeterministicGetWeakMapKeys(wn_live_map).length, 1,
       "Live weak map wrapped native key should not be removed.");

    ok(wn_live_map.has(get_live_dom()), "Live map should have live dom.");

    SimpleTest.finish();
  });

  ]]>
  </script>
</window>