The Tor Browser: addon-sdk/source/test/test-disposable.js@ac0c01689b40

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     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 "use strict";

     6 const { Loader } = require("sdk/test/loader");

     7 const { Class } = require("sdk/core/heritage");

     8 const { Disposable } = require("sdk/core/disposable");

     9 const { Cc, Ci, Cu } = require("chrome");

    10 const { setTimeout } = require("sdk/timers");

    12 exports["test destroy reasons"] = assert => {

    13   const Foo = Class({

    14     extends: Disposable,

    15     dispose: function() {

    16       disposals = disposals + 1;

    17     }

    18   });

    20   let disposals = 0;

    21   const f1 = new Foo();

    23   f1.destroy();

    24   assert.equal(disposals, 1, "disposed on destroy");

    25   f1.destroy();

    26   assert.equal(disposals, 1, "second destroy is ignored");

    28   disposals = 0;

    29   const f2 = new Foo();

    31   f2.destroy("uninstall");

    32   assert.equal(disposals, 1, "uninstall invokes disposal");

    33   f2.destroy("uninstall")

    34   f2.destroy();

    35   assert.equal(disposals, 1, "disposal happens just once");

    37   disposals = 0;

    38   const f3 = new Foo();

    40   f3.destroy("shutdown");

    41   assert.equal(disposals, 0, "shutdown doesn't invoke disposal");

    42   f3.destroy();

    43   assert.equal(disposals, 0, "shutdown already skipped disposal");

    45   disposals = 0;

    46   const f4 = new Foo();

    48   f4.destroy("disable");

    49   assert.equal(disposals, 1, "disable invokes disposal");

    50   f4.destroy("disable")

    51   f4.destroy();

    52   assert.equal(disposals, 1, "destroy happens just once");

    54   disposals = 0;

    55   const f5 = new Foo();

    57   f5.destroy("disable");

    58   assert.equal(disposals, 1, "disable invokes disposal");

    59   f5.destroy("disable")

    60   f5.destroy();

    61   assert.equal(disposals, 1, "destroy happens just once");

    63   disposals = 0;

    64   const f6 = new Foo();

    66   f6.destroy("upgrade");

    67   assert.equal(disposals, 1, "upgrade invokes disposal");

    68   f6.destroy("upgrade")

    69   f6.destroy();

    70   assert.equal(disposals, 1, "destroy happens just once");

    72   disposals = 0;

    73   const f7 = new Foo();

    75   f7.destroy("downgrade");

    76   assert.equal(disposals, 1, "downgrade invokes disposal");

    77   f7.destroy("downgrade")

    78   f7.destroy();

    79   assert.equal(disposals, 1, "destroy happens just once");

    82   disposals = 0;

    83   const f8 = new Foo();

    85   f8.destroy("whatever");

    86   assert.equal(disposals, 1, "unrecognized reason invokes disposal");

    87   f8.destroy("meh")

    88   f8.destroy();

    89   assert.equal(disposals, 1, "destroy happens just once");

    90 };

    92 exports["test different unload hooks"] = assert => {

    93   const { uninstall, shutdown, disable, upgrade,

    94           downgrade, dispose } = require("sdk/core/disposable");

    95   const UberUnload = Class({

    96     extends: Disposable,

    97     setup: function() {

    98       this.log = [];

    99     }

   100   });

   102   uninstall.define(UberUnload, x => x.log.push("uninstall"));

   103   shutdown.define(UberUnload, x => x.log.push("shutdown"));

   104   disable.define(UberUnload, x => x.log.push("disable"));

   105   upgrade.define(UberUnload, x => x.log.push("upgrade"));

   106   downgrade.define(UberUnload, x => x.log.push("downgrade"));

   107   dispose.define(UberUnload, x => x.log.push("dispose"));

   109   const u1 = new UberUnload();

   110   u1.destroy("uninstall");

   111   u1.destroy();

   112   u1.destroy("shutdown");

   113   assert.deepEqual(u1.log, ["uninstall"], "uninstall hook invoked");

   115   const u2 = new UberUnload();

   116   u2.destroy("shutdown");

   117   u2.destroy();

   118   u2.destroy("uninstall");

   119   assert.deepEqual(u2.log, ["shutdown"], "shutdown hook invoked");

   121   const u3 = new UberUnload();

   122   u3.destroy("disable");

   123   u3.destroy();

   124   u3.destroy("uninstall");

   125   assert.deepEqual(u3.log, ["disable"], "disable hook invoked");

   127   const u4 = new UberUnload();

   128   u4.destroy("upgrade");

   129   u4.destroy();

   130   u4.destroy("uninstall");

   131   assert.deepEqual(u4.log, ["upgrade"], "upgrade hook invoked");

   133   const u5 = new UberUnload();

   134   u5.destroy("downgrade");

   135   u5.destroy();

   136   u5.destroy("uninstall");

   137   assert.deepEqual(u5.log, ["downgrade"], "downgrade hook invoked");

   139   const u6 = new UberUnload();

   140   u6.destroy();

   141   u6.destroy();

   142   u6.destroy("uninstall");

   143   assert.deepEqual(u6.log, ["dispose"], "dispose hook invoked");

   145   const u7 = new UberUnload();

   146   u7.destroy("whatever");

   147   u7.destroy();

   148   u7.destroy("uninstall");

   149   assert.deepEqual(u7.log, ["dispose"], "dispose hook invoked");

   150 };

   152 exports["test disposables are desposed on unload"] = function(assert) {

   153   let loader = Loader(module);

   154   let { Disposable } = loader.require("sdk/core/disposable");

   156   let arg1 = {}

   157   let arg2 = 2

   158   let disposals = 0

   160   let Foo = Class({

   161     extends: Disposable,

   162     setup: function setup(a, b) {

   163       assert.equal(a, arg1,

   164                    "arguments passed to constructur is passed to setup");

   165       assert.equal(b, arg2,

   166                    "second argument is also passed to a setup");

   167       assert.ok(this instanceof Foo,

   168                 "this is an instance in the scope of the setup method");

   170       this.fooed = true

   171     },

   172     dispose: function dispose() {

   173       assert.equal(this.fooed, true, "attribute was set")

   174       this.fooed = false

   175       disposals = disposals + 1

   176     }

   177   })

   179   let foo1 = Foo(arg1, arg2)

   180   let foo2 = Foo(arg1, arg2)

   182   loader.unload();

   184   assert.equal(disposals, 2, "both instances were disposed")

   185 }

   187 exports["test destroyed windows dispose before unload"] = function(assert) {

   188   let loader = Loader(module);

   189   let { Disposable } = loader.require("sdk/core/disposable");

   191   let arg1 = {}

   192   let arg2 = 2

   193   let disposals = 0

   195   let Foo = Class({

   196     extends: Disposable,

   197     setup: function setup(a, b) {

   198       assert.equal(a, arg1,

   199                    "arguments passed to constructur is passed to setup");

   200       assert.equal(b, arg2,

   201                    "second argument is also passed to a setup");

   202       assert.ok(this instanceof Foo,

   203                 "this is an instance in the scope of the setup method");

   205       this.fooed = true

   206     },

   207     dispose: function dispose() {

   208       assert.equal(this.fooed, true, "attribute was set")

   209       this.fooed = false

   210       disposals = disposals + 1

   211     }

   212   })

   214   let foo1 = Foo(arg1, arg2)

   215   let foo2 = Foo(arg1, arg2)

   217   foo1.destroy();

   218   assert.equal(disposals, 1, "destroy disposes instance")

   220   loader.unload();

   222   assert.equal(disposals, 2, "unload disposes alive instances")

   223 }

   225 exports["test disposables are GC-able"] = function(assert, done) {

   226   let loader = Loader(module);

   227   let { Disposable } = loader.require("sdk/core/disposable");

   228   let { WeakReference } = loader.require("sdk/core/reference");

   230   let arg1 = {}

   231   let arg2 = 2

   232   let disposals = 0

   234   let Foo = Class({

   235     extends: Disposable,

   236     implements: [WeakReference],

   237     setup: function setup(a, b) {

   238       assert.equal(a, arg1,

   239                    "arguments passed to constructur is passed to setup");

   240       assert.equal(b, arg2,

   241                    "second argument is also passed to a setup");

   242       assert.ok(this instanceof Foo,

   243                 "this is an instance in the scope of the setup method");

   245       this.fooed = true

   246     },

   247     dispose: function dispose() {

   248       assert.equal(this.fooed, true, "attribute was set")

   249       this.fooed = false

   250       disposals = disposals + 1

   251     }

   252   });

   254   let foo1 = Foo(arg1, arg2)

   255   let foo2 = Foo(arg1, arg2)

   257   let foo1 = null

   258   let foo2 = null

   260   Cu.schedulePreciseGC(function() {

   261     loader.unload();

   262     assert.equal(disposals, 0, "GC removed dispose listeners");

   263     done();

   264   });

   265 }

   268 exports["test loader unloads do not affect other loaders"] = function(assert) {

   269   let loader1 = Loader(module);

   270   let loader2 = Loader(module);

   271   let { Disposable: Disposable1 } = loader1.require("sdk/core/disposable");

   272   let { Disposable: Disposable2 } = loader2.require("sdk/core/disposable");

   274   let arg1 = {}

   275   let arg2 = 2

   276   let disposals = 0

   278   let Foo1 = Class({

   279     extends: Disposable1,

   280     dispose: function dispose() {

   281       disposals = disposals + 1;

   282     }

   283   });

   285   let Foo2 = Class({

   286     extends: Disposable2,

   287     dispose: function dispose() {

   288       disposals = disposals + 1;

   289     }

   290   });

   292   let foo1 = Foo1(arg1, arg2);

   293   let foo2 = Foo2(arg1, arg2);

   295   assert.equal(disposals, 0, "no destroy calls");

   297   loader1.unload();

   299   assert.equal(disposals, 1, "1 destroy calls");

   301   loader2.unload();

   303   assert.equal(disposals, 2, "2 destroy calls");

   304 }

   306 exports["test disposables that throw"] = function(assert) {

   307   let loader = Loader(module);

   308   let { Disposable } = loader.require("sdk/core/disposable");

   310   let disposals = 0

   312   let Foo = Class({

   313     extends: Disposable,

   314     setup: function setup(a, b) {

   315       throw Error("Boom!")

   316     },

   317     dispose: function dispose() {

   318       disposals = disposals + 1

   319     }

   320   })

   322   assert.throws(function() {

   323     let foo1 = Foo()

   324   }, /Boom/, "disposable constructors may throw");

   326   loader.unload();

   328   assert.equal(disposals, 0, "no disposal if constructor threw");

   329 }

   331 exports["test multiple destroy"] = function(assert) {

   332   let loader = Loader(module);

   333   let { Disposable } = loader.require("sdk/core/disposable");

   335   let disposals = 0

   337   let Foo = Class({

   338     extends: Disposable,

   339     dispose: function dispose() {

   340       disposals = disposals + 1

   341     }

   342   })

   344   let foo1 = Foo();

   345   let foo2 = Foo();

   346   let foo3 = Foo();

   348   assert.equal(disposals, 0, "no disposals yet");

   350   foo1.destroy();

   351   assert.equal(disposals, 1, "disposed properly");

   352   foo1.destroy();

   353   assert.equal(disposals, 1, "didn't attempt to dispose twice");

   355   foo2.destroy();

   356   assert.equal(disposals, 2, "other instances still dispose fine");

   357   foo2.destroy();

   358   assert.equal(disposals, 2, "but not twice");

   360   loader.unload();

   362   assert.equal(disposals, 3, "unload only disposed the remaining instance");

   363 }

   365 require('test').run(exports);

The Tor Browser / file revision

addon-sdk/source/test/test-disposable.js@ac0c01689b40

addon-sdk/source/test/test-disposable.js