tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

clone-transferables.js (4564B)

      1 // |reftest| skip-if(!xulRuntime.shell)
      2 // Any copyright is dedicated to the Public Domain.
      3 // http://creativecommons.org/licenses/publicdomain/
      4 
      5 function* buffer_options() {
      6    for (var scope of ["SameProcess",
      7                       "DifferentProcess",
      8                       "DifferentProcessForIndexedDB"])
      9    {
     10        for (var size of [0, 8, 16, 200, 1000, 4096, 8192, 65536]) {
     11            yield { scope, size };
     12        }
     13    }
     14 }
     15 
     16 
     17 function test() {
     18    for (var {scope, size} of buffer_options()) {
     19        var old = new ArrayBuffer(size);
     20        var copy = deserialize(serialize([old, old], [old], { scope }), { scope });
     21        assertEq(old.byteLength, 0);
     22        assertEq(copy[0] === copy[1], true);
     23        copy = copy[0];
     24        assertEq(copy.byteLength, size);
     25 
     26        var constructors = [ Int8Array,
     27                             Uint8Array,
     28                             Int16Array,
     29                             Uint16Array,
     30                             Int32Array,
     31                             Uint32Array,
     32                             Float32Array,
     33                             Float64Array,
     34                             Uint8ClampedArray,
     35                             DataView ];
     36 
     37        for (var ctor of constructors) {
     38            var dataview = (ctor === DataView);
     39 
     40            var buf = new ArrayBuffer(size);
     41            var old_arr = new ctor(buf);
     42            assertEq(buf.byteLength, size);
     43            assertEq(buf, old_arr.buffer);
     44            if (!dataview)
     45                assertEq(old_arr.length, size / old_arr.BYTES_PER_ELEMENT);
     46 
     47            var copy_arr = deserialize(serialize(old_arr, [ buf ], { scope }), { scope });
     48            assertEq(buf.byteLength, 0,
     49                     "donor array buffer should be detached");
     50            if (!dataview) {
     51                assertEq(old_arr.length, 0,
     52                         "donor typed array should be detached");
     53            }
     54            assertEq(copy_arr.buffer.byteLength == size, true);
     55            if (!dataview)
     56                assertEq(copy_arr.length, size / old_arr.BYTES_PER_ELEMENT);
     57 
     58            buf = null;
     59            old_arr = null;
     60            gc(); // Tickle the ArrayBuffer -> view management
     61        }
     62 
     63        for (var ctor of constructors) {
     64            var dataview = (ctor === DataView);
     65 
     66            var buf = new ArrayBuffer(size);
     67            var old_arr = new ctor(buf);
     68            var dv = new DataView(buf); // Second view
     69            var copy_arr = deserialize(serialize(old_arr, [ buf ], { scope }), { scope });
     70            assertEq(buf.byteLength, 0,
     71                     "donor array buffer should be detached");
     72            if (!dataview) {
     73                assertEq(old_arr.byteLength, 0,
     74                         "donor typed array should be detached");
     75                assertEq(old_arr.length, 0,
     76                         "donor typed array should be detached");
     77            }
     78 
     79            buf = null;
     80            old_arr = null;
     81            gc(); // Tickle the ArrayBuffer -> view management
     82        }
     83 
     84        // Mutate the buffer during the clone operation. The modifications should be visible.
     85        if (size >= 4) {
     86            old = new ArrayBuffer(size);
     87            var view = new Int32Array(old);
     88            view[0] = 1;
     89            var mutator = { get foo() { view[0] = 2; } };
     90            var copy = deserialize(serialize([ old, mutator ], [ old ], { scope }), { scope });
     91            var viewCopy = new Int32Array(copy[0]);
     92            assertEq(view.length, 0); // Underlying buffer now detached.
     93            assertEq(viewCopy[0], 2);
     94        }
     95 
     96        // Detach the buffer during the clone operation. Should throw an
     97        // exception.
     98        if (size >= 4) {
     99            const b1 = new ArrayBuffer(size);
    100            let mutator = {
    101                get foo() {
    102                    serialize(b1, [b1], { scope });
    103                }
    104            };
    105 
    106            assertThrowsInstanceOf(
    107                () => serialize([ b1, mutator ], [b1]),
    108                TypeError,
    109                "detaching (due to Transferring) while serializing should throw"
    110            );
    111 
    112            const b2 = new ArrayBuffer(size);
    113            mutator = {
    114                get foo() {
    115                    detachArrayBuffer(b2);
    116                }
    117            };
    118 
    119            assertThrowsInstanceOf(
    120                () => serialize([ b2, mutator ], [b2]),
    121                TypeError,
    122                "detaching (due to detachArrayBuffer) while serializing should throw"
    123            );
    124        }
    125    }
    126 }
    127 
    128 test();
    129 reportCompare(0, 0, 'ok');