tor-browser

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

video-frame-serialization.any.js (3719B)

      1 // META: global=window,dedicatedworker
      2 // META: script=/common/media.js
      3 // META: script=/webcodecs/utils.js
      4 
      5 var defaultInit = {
      6  timestamp : 100,
      7  duration : 33,
      8 }
      9 
     10 function createDefaultVideoFrame() {
     11  let image = makeImageBitmap(32,16);
     12 
     13  return new VideoFrame(image, defaultInit);
     14 }
     15 
     16 test(t => {
     17  let frame = createDefaultVideoFrame();
     18 
     19  let clone = frame.clone();
     20 
     21  assert_equals(frame.timestamp, clone.timestamp);
     22  assert_equals(frame.duration, clone.duration);
     23  assert_equals(frame.visibleRect.left, clone.visibleRect.left);
     24  assert_equals(frame.visibleRect.top, clone.visibleRect.top);
     25  assert_equals(frame.visibleRect.width, clone.visibleRect.width);
     26  assert_equals(frame.visibleRect.height, clone.visibleRect.height);
     27 
     28  frame.close();
     29  assert_true(isFrameClosed(frame));
     30  clone.close();
     31  assert_true(isFrameClosed(clone));
     32 }, 'Test we can clone a VideoFrame.');
     33 
     34 test(t => {
     35  let frame = createDefaultVideoFrame();
     36 
     37  let copy = frame;
     38  let clone = frame.clone();
     39 
     40  frame.close();
     41 
     42  assert_equals(copy.timestamp, defaultInit.timestamp);
     43  assert_equals(copy.duration, defaultInit.duration);
     44  assert_true(isFrameClosed(copy));
     45  assert_equals(clone.timestamp, defaultInit.timestamp);
     46  assert_false(isFrameClosed(clone));
     47 
     48  clone.close();
     49 }, 'Verify closing a frame doesn\'t affect its clones.');
     50 
     51 test(t => {
     52  let frame = createDefaultVideoFrame();
     53 
     54  frame.close();
     55 
     56  assert_throws_dom("InvalidStateError", () => {
     57    let clone = frame.clone();
     58  });
     59 }, 'Verify cloning a closed frame throws.');
     60 
     61 async_test(t => {
     62  let localFrame = createDefaultVideoFrame();
     63 
     64  let channel = new MessageChannel();
     65  let localPort = channel.port1;
     66  let externalPort = channel.port2;
     67 
     68  externalPort.onmessage = t.step_func((e) => {
     69    let externalFrame = e.data;
     70    externalFrame.close();
     71    externalPort.postMessage("Done");
     72  })
     73 
     74  localPort.onmessage = t.step_func_done((e) => {
     75    assert_equals(localFrame.timestamp, defaultInit.timestamp);
     76    localFrame.close();
     77  })
     78 
     79  localPort.postMessage(localFrame);
     80 }, 'Verify closing frames does not propagate accross contexts.');
     81 
     82 async_test(t => {
     83  let localFrame = createDefaultVideoFrame();
     84 
     85  let channel = new MessageChannel();
     86  let localPort = channel.port1;
     87  let externalPort = channel.port2;
     88 
     89  externalPort.onmessage = t.step_func_done((e) => {
     90    let externalFrame = e.data;
     91    assert_equals(externalFrame.timestamp, defaultInit.timestamp);
     92    externalFrame.close();
     93  })
     94 
     95  localPort.postMessage(localFrame, [localFrame]);
     96  assert_true(isFrameClosed(localFrame));
     97 }, 'Verify transferring frames closes them.');
     98 
     99 async_test(t => {
    100  let localFrame = createDefaultVideoFrame();
    101 
    102  let channel = new MessageChannel();
    103  let localPort = channel.port1;
    104 
    105  localPort.onmessage = t.unreached_func();
    106 
    107  localFrame.close();
    108 
    109  assert_throws_dom("DataCloneError", () => {
    110    localPort.postMessage(localFrame);
    111  });
    112 
    113  t.done();
    114 }, 'Verify posting closed frames throws.');
    115 
    116 promise_test(async t => {
    117  const open = indexedDB.open('VideoFrameTestDB', 1);
    118  open.onerror = t.unreached_func('open should succeed');
    119  open.onupgradeneeded = (event) => {
    120    let db = event.target.result;
    121    db.createObjectStore('MyVideoFrames', { keyPath: 'id' });
    122  };
    123  let db = await new Promise((resolve) => {
    124    open.onsuccess = (e) => {
    125      resolve(e.target.result);
    126    };
    127  });
    128  t.add_cleanup(() => {
    129    db.close();
    130    indexedDB.deleteDatabase(db.name);
    131  });
    132 
    133  let transaction = db.transaction(['MyVideoFrames'], 'readwrite');
    134  const store = transaction.objectStore('MyVideoFrames');
    135  let frame = createDefaultVideoFrame();
    136  assert_throws_dom("DataCloneError", () => {
    137    store.add(frame);
    138  });
    139 }, 'Verify storing a frame throws.');