shared-storage/resources/util.js

// META: script=/common/utils.js
// META: script=/fenced-frame/resources/utils.js
'use strict';

async function IsSharedStorageSelectUrlAllowed() {
  let allowed = true;
  try {
    await sharedStorage.selectURL("operation", [{url: "1.html"}]);
  } catch (e) {
    allowed = false;
  }

  return allowed;
}

// Execute all shared storage methods (excluding createWorklet).
// and capture their errors. Return true if all methods succeed.
async function AreRegularSharedStorageMethodsAllowed() {
  let deniedCount = 0;

  try {
    await window.sharedStorage.worklet.addModule('/shared-storage/resources/simple-module.js');
  } catch (e) {
    ++deniedCount;
  }

  try {
    await window.sharedStorage.run('operation', {keepAlive: true});
  } catch (e) {
    ++deniedCount;
  }

  try {
    await sharedStorage.selectURL("operation", [{url: "1.html"}], {keepAlive: true});
  } catch (e) {
    ++deniedCount;
  }

  try {
    await window.sharedStorage.set('a', 'b');
  } catch (e) {
    ++deniedCount;
  }

  try {
    await window.sharedStorage.append('a', 'b');
  } catch (e) {
    ++deniedCount;
  }

  try {
    await window.sharedStorage.clear();
  } catch (e) {
    ++deniedCount;
  }

  try {
    await window.sharedStorage.delete('a');
  } catch (e) {
    ++deniedCount;
  }

  if (deniedCount === 0)
    return true;

  return false;
}

// Run sharedStorage.worklet.addModule once.
// @param {string} module - The URL to the module.
async function addModuleOnce(module) {
  try {
    await sharedStorage.worklet.addModule(module);
  } catch (e) {
    // Shared Storage needs to have a module added before we can operate on it.
    // It is generated on the fly with this call, and since there's no way to
    // tell through the API if a module already exists, wrap the addModule call
    // in a try/catch so that if it runs a second time in a test, it will
    // gracefully fail rather than bring the whole test down.
  }
}

// Validate the type of the result of sharedStorage.worklet.selectURL.
// @param result - The result of sharedStorage.worklet.selectURL.
// @param {boolean} - Whether sharedStorage.worklet.selectURL is resolved to
//                    a fenced frame config (true) or an urn:uuid (false).
// @return {boolean} Whether sharedStorage.worklet.selectURL returns an expected
//                   result type or not.
function validateSelectURLResult(result, resolve_to_config) {
  if (resolve_to_config) {
    return result instanceof FencedFrameConfig;
  }

  return result.startsWith('urn:uuid:');
}

function updateUrlToUseNewOrigin(url, newOriginString) {
  const origin = url.origin;
  return new URL(url.toString().replace(origin, newOriginString));
}

function appendExpectedKeyAndValue(url, expectedKey, expectedValue) {
  url.searchParams.append('expectedKey', expectedKey);
  url.searchParams.append('expectedValue', expectedValue);
  return url;
}

function parseExpectedKeyAndValueData() {
  const url = new URL(location.href);
  const key = url.searchParams.get('expectedKey');
  const value = url.searchParams.get('expectedValue');
  return {'expectedKey': key, 'expectedValue': value};
}

function appendExpectedKey(url, expectedKey) {
  url.searchParams.append('expectedKey', expectedKey);
  return url;
}

function parseExpectedKeyData() {
  const url = new URL(location.href);
  const key = url.searchParams.get('expectedKey');
  return {'expectedKey': key};
}

async function verifyKeyValueForOrigin(key, value, origin) {
  const outerKey = token();
  const innerKey = token();
  let iframeUrl = generateURL(
      '/shared-storage/resources/verify-key-value.https.html',
      [outerKey, innerKey]);
  iframeUrl = updateUrlToUseNewOrigin(iframeUrl, origin);
  iframeUrl = appendExpectedKeyAndValue(iframeUrl, key, value);

  attachIFrame(iframeUrl);
  const result = await nextValueFromServer(outerKey);
  assert_equals(result, 'verify_key_value_loaded');
}

async function verifyKeyNotFoundForOrigin(key, origin) {
  const outerKey = token();
  const innerKey = token();
  let iframeUrl = generateURL(
      '/shared-storage/resources/verify-key-not-found.https.html',
      [outerKey, innerKey]);
  iframeUrl = updateUrlToUseNewOrigin(iframeUrl, origin);
  iframeUrl = appendExpectedKey(iframeUrl, key);

  attachIFrame(iframeUrl);
  const result = await nextValueFromServer(outerKey);
  assert_equals(result, 'verify_key_not_found_loaded');
}

async function setKeyValueForOrigin(key, value, origin) {
  const outerKey = token();
  let setIframeUrl = generateURL(
      '/shared-storage/resources/set-key-value.https.html', [outerKey]);
  setIframeUrl = updateUrlToUseNewOrigin(setIframeUrl, origin);
  setIframeUrl = appendExpectedKeyAndValue(setIframeUrl, key, value);

  attachIFrame(setIframeUrl);
  const result = await nextValueFromServer(outerKey);
  assert_equals(result, 'set_key_value_loaded');
}

async function deleteKeyForOrigin(key, origin) {
  const outerKey = token();
  let deleteIframeUrl = generateURL(
      '/shared-storage/resources/delete-key.https.html', [outerKey]);
  deleteIframeUrl = updateUrlToUseNewOrigin(deleteIframeUrl, origin);
  deleteIframeUrl = appendExpectedKey(deleteIframeUrl, key);

  attachIFrame(deleteIframeUrl);
  const result = await nextValueFromServer(outerKey);
  assert_equals(result, 'delete_key_loaded');
}

function getFetchedUrls(worker) {
  return new Promise(function(resolve) {
    var channel = new MessageChannel();
    channel.port1.onmessage = function(msg) {
      resolve(msg);
    };
    worker.postMessage({port: channel.port2}, [channel.port2]);
  });
}

function checkInterceptedUrls(worker, expectedRequests) {
  return getFetchedUrls(worker).then(function(msg) {
    let actualRequests = msg.data.requests;
    assert_equals(actualRequests.length, expectedRequests.length);
    assert_equals(
        JSON.stringify(actualRequests), JSON.stringify(expectedRequests));
  });
}

function attachIFrameWithEventListenerForSelectURLStatus(url) {
  const frame = document.createElement('iframe');
  frame.src = url;

  const promise = new Promise((resolve, reject) => {
    window.addEventListener('message', async function handler(evt) {
      if (evt.source === frame.contentWindow && evt.data.selectURLStatus) {
        document.body.removeChild(frame);
        window.removeEventListener('message', handler);
        if (evt.data.selectURLStatus === 'success') {
          resolve(evt.data);
        } else {
          reject(new Error(JSON.stringify(evt.data)));
        }
      }
    });
  });

  document.body.appendChild(frame);
  return promise;
}