tor-browser

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

test_blob_sliced_from_parent_process.js (4326B)

      1 "use strict";
      2 
      3 const { XPCShellContentUtils } = ChromeUtils.importESModule(
      4  "resource://testing-common/XPCShellContentUtils.sys.mjs"
      5 );
      6 
      7 XPCShellContentUtils.init(this);
      8 
      9 function childFrameScript() {
     10  /* eslint-env mozilla/frame-script */
     11  const messageName = "test:blob-slice-test";
     12  const blobData = ["So", " ", "many", " ", "blobs!"];
     13  const blobText = blobData.join("");
     14  const blobType = "text/plain";
     15 
     16  const sliceText = "an";
     17 
     18  function info(msg) {
     19    sendAsyncMessage(messageName, { op: "info", msg });
     20  }
     21 
     22  function ok(condition, name, diag) {
     23    sendAsyncMessage(messageName, { op: "ok", condition, name, diag });
     24  }
     25 
     26  function is(a, b, name) {
     27    let pass = a == b;
     28    let diag = pass ? "" : "got " + a + ", expected " + b;
     29    ok(pass, name, diag);
     30  }
     31 
     32  function finish(result) {
     33    sendAsyncMessage(messageName, { op: "done", result });
     34  }
     35 
     36  function grabAndContinue(arg) {
     37    testGenerator.next(arg);
     38  }
     39 
     40  function* testSteps() {
     41    addMessageListener(messageName, grabAndContinue);
     42    let message = yield undefined;
     43 
     44    let blob = message.data;
     45 
     46    ok(Blob.isInstance(blob), "Received a Blob");
     47    is(blob.size, blobText.length, "Blob has correct length");
     48    is(blob.type, blobType, "Blob has correct type");
     49 
     50    info("Reading blob");
     51 
     52    let reader = new FileReader();
     53    reader.addEventListener("load", grabAndContinue);
     54    reader.readAsText(blob);
     55 
     56    yield undefined;
     57 
     58    is(reader.result, blobText, "Blob has correct data");
     59 
     60    let firstSliceStart = blobData[0].length + blobData[1].length;
     61    let firstSliceEnd = firstSliceStart + blobData[2].length;
     62 
     63    let slice = blob.slice(firstSliceStart, firstSliceEnd, blobType);
     64 
     65    ok(Blob.isInstance(slice), "Slice returned a Blob");
     66    is(slice.size, blobData[2].length, "Slice has correct length");
     67    is(slice.type, blobType, "Slice has correct type");
     68 
     69    info("Reading slice");
     70 
     71    reader = new FileReader();
     72    reader.addEventListener("load", grabAndContinue);
     73    reader.readAsText(slice);
     74 
     75    yield undefined;
     76 
     77    is(reader.result, blobData[2], "Slice has correct data");
     78 
     79    let secondSliceStart = blobData[2].indexOf("a");
     80    let secondSliceEnd = secondSliceStart + sliceText.length;
     81 
     82    slice = slice.slice(secondSliceStart, secondSliceEnd, blobType);
     83 
     84    ok(Blob.isInstance(slice), "Second slice returned a Blob");
     85    is(slice.size, sliceText.length, "Second slice has correct length");
     86    is(slice.type, blobType, "Second slice has correct type");
     87 
     88    info("Sending second slice");
     89    finish(slice);
     90  }
     91 
     92  let testGenerator = testSteps();
     93  testGenerator.next();
     94 }
     95 
     96 add_task(async function test() {
     97  let page = await XPCShellContentUtils.loadContentPage(
     98    "data:text/html,<!DOCTYPE HTML><html><body></body></html>",
     99    {
    100      remote: true,
    101    }
    102  );
    103 
    104  page.loadFrameScript(childFrameScript);
    105 
    106  const messageName = "test:blob-slice-test";
    107  const blobData = ["So", " ", "many", " ", "blobs!"];
    108  const blobType = "text/plain";
    109 
    110  const sliceText = "an";
    111 
    112  await new Promise(resolve => {
    113    function grabAndContinue(arg) {
    114      testGenerator.next(arg);
    115    }
    116 
    117    function* testSteps() {
    118      let slice = yield undefined;
    119 
    120      ok(Blob.isInstance(slice), "Received a Blob");
    121      equal(slice.size, sliceText.length, "Slice has correct size");
    122      equal(slice.type, blobType, "Slice has correct type");
    123 
    124      let reader = new FileReader();
    125      reader.onload = grabAndContinue;
    126      reader.readAsText(slice);
    127      yield undefined;
    128 
    129      equal(reader.result, sliceText, "Slice has correct data");
    130      resolve();
    131    }
    132 
    133    let testGenerator = testSteps();
    134    testGenerator.next();
    135 
    136    let mm = page.browser.messageManager;
    137    mm.addMessageListener(messageName, function (message) {
    138      let data = message.data;
    139      switch (data.op) {
    140        case "info": {
    141          info(data.msg);
    142          break;
    143        }
    144 
    145        case "ok": {
    146          ok(data.condition, data.name + " - " + data.diag);
    147          break;
    148        }
    149 
    150        case "done": {
    151          testGenerator.next(data.result);
    152          break;
    153        }
    154 
    155        default: {
    156          ok(false, "Unknown op: " + data.op);
    157          resolve();
    158        }
    159      }
    160    });
    161 
    162    let blob = new Blob(blobData, { type: blobType });
    163    mm.sendAsyncMessage(messageName, blob);
    164  });
    165 
    166  await page.close();
    167 });