Controlled Frame API

When a controlledframe element element is inserted into a document whose browsing context is non-null, run the following steps:

1. If element’s src is not empty, then:

   1. Initialize a controlledframe given element.

When a controlledframe element element is removed from a document, run the following steps:

1. Destroy a top-level traversable given element’s embedded navigable.

2. Set element’s embedded navigable to null.

To initialize a controlledframe element element, run the following steps:

1. Assert that element’s embedded navigable is null.

2. Let group be a new browsing context group.

3. Let document be the second return value of creating a new browsing context and document given element’s node document, element, and group.

4. Let documentState be a new document state, whose document is document.

5. Let traversable be a new traversable navigable.

6. Initialize the navigable traversable given documentState.

7. Set traversable’s embedderParent to element.

8. Set element’s embedded navigable to traversable.

9. Let initialHistoryEntry be traversable’s active session history entry.

10. Set initialHistoryEntry’s step to 0.

11. Append initialHistoryEntry to traversable’s session history entries.

    These steps are needed to initialize History.length in the new navigable. This is an existing issue in the HTML Standard.

12. Set element’s contentWindow to document’s WindowProxy.

13. Navigate a controlledframe given element and element’s src.

To navigate a controlledframe element element given a USVString urlString, run the following steps:

1. If urlString is not an absolute-URL string, return.

2. Let url be the result of parsing a URL given urlString and element’s node document.

3. Let historyHandling be "auto".

4. If element’s embedded navigable’s active document is not completely loaded, then set historyHandling to "replace".

5. Navigate element’s embedded navigable to url using element’s node document, with a NavigationHistoryBehavior of historyHandling.

The HTMLControlledFrameElement() constructor steps are:

1. Set this’s request to a new WebRequest.

2. Set this’s contextMenus to a new ContextMenus.

To resolve an embedder promise given a controlledframe controlledframe, a promise promise, and an optional value, run the following steps:

1. Queue a global task on the DOM manipulation task source of controlledframe’s relevant global object to resolve promise with value.

   Note: The relevant global object of controlledframe is the embedder’s Window object.

To reject an embedder promise given a controlledframe controlledframe, a promise promise, and an optional value, run the following steps:

1. Queue a global task on the DOM manipulation task source of controlledframe’s relevant global object to reject promise with value.

   Note: The relevant global object of controlledframe is the embedder’s Window object.

A URL url matches a URLPattern pattern if the following steps return true:

1. Let result be the result of match given pattern, and url.

2. If result is null, then return false.

3. Return true.

The partition IDL attribute setter steps are:

1. If this’s embedded navigable is not null, then:

   1. Throw a "NotSupportedError" DOMException.

2. Set this’s partition to the given value.

The src IDL attribute setter steps are:

1. If this is not in a document tree, then return.

2. If this’s embedded navigable is null, then:

   1. Initialize a controlledframe given this.

3. Otherwise:

   1. Navigate a controlledframe given this and the given value.

To delta traverse an embedded navigable’s history, given a controlledframe controlledframe and an integer delta, run the following steps:

1. Let resultPromise be a new promise.

2. Return resultPromise and run the remaining steps in parallel.

3. Let embeddedNavigable be controlledframe’s embedded navigable.

4. If embeddedNavigable is null, then resolve an embedder promise given controlledframe, resultPromise, and false, and abort these steps.

5. If embeddedNavigable’s active document is not fully active, then resolve an embedder promise given controlledframe, resultPromise, and false, and abort these steps.

6. Append the following session history traversal steps to embeddedNavigable:

   1. Let allSteps be the result of getting all used history steps for embeddedNavigable.

   2. Let currentStepIndex be the index of embeddedNavigable’s current session history step within allSteps.

   3. Let targetStepIndex be currentStepIndex + delta.

   4. If allSteps[targetStepIndex] does not exist, then resolve an embedder promise given controlledframe, resultPromise, and false, and abort these steps.

   5. Let result be the result of applying the traverse history step allSteps[targetStepIndex] to embeddedNavigable given a user navigation involvement of "none".

   6. If result is not equal to "applied", then resolve an embedder promise given controlledframe, resultPromise, and false.

   7. Otherwise, resolve an embedder promise given controlledframe, resultPromise, and true.

The canGoBack() method steps are:

1. Let result be a new promise.

2. Let controlledframe be this.

3. Let embeddedNavigable be controlledframe’s embedded navigable.

4. If embeddedNavigable is null, then resolve result with false and return result.

5. Queue a global task on the navigation and traversal task source of embeddedNavigable’s node document’s relevant global object that will run the following steps:

   1. Let canGoBack be true if embeddedNavigable’s current session history step is > 0, false otherwise.

   2. Resolve an embedder promise given controlledframe, result, and canGoBack.

6. Return result.

The canGoForward() method steps are:

1. Let result be a new promise.

2. Let controlledframe be this.

3. Let embeddedNavigable be controlledframe’s embedded navigable.

4. If embeddedNavigable is null, then resolve result with false and return result.

5. Queue a global task on the navigation and traversal task source of embeddedNavigable’s node document’s relevant global object that will run the following steps:

   1. Let step be embeddedNavigable’s current session history step.

   2. Let steps be the result of getting all used history steps given embeddedNavigable.

   3. Let canGoForward be true if step + 1 < the size of steps, false otherwise.

   4. Resolve an embedder promise given controlledframe, result, and canGoForward.

6. Return result.

The back() method steps are:

1. Return the result of delta traverse an embedded navigable’s history given this and -1.

The forward() method steps are:

1. Return the result of delta traverse an embedded navigable’s history given this and 1.

The go(relativeIndex) method steps are:

1. Return the result of delta traverse an embedded navigable’s history given this and relativeIndex.

The reload() steps are:

1. Let embeddedNavigable be this’s embedded navigable.

2. If embeddedNavigable is null, return.

3. Queue a global task on the navigation and traversal task source of embeddedNavigable’s node document’s relevant global object that will reload embeddedNavigable given a user navigation involvement of "none".

The stop() steps are:

1. Let embeddedNavigable be this’s embedded navigable.

2. If embeddedNavigable is null, return.

3. Queue a global task on the navigation and traversal task source of embeddedNavigable’s node document’s relevant global object that will stop loading embeddedNavigable.

// One of |code| or |file| must be specified but not both.
dictionary InjectDetails {
  DOMString code;
  USVString file;
};

dictionary InjectionItems {
  DOMString code;
  sequence<USVString> files;
};

enum RunAt {
  "document-start",
  "document-end",
  "document-idle",
};

dictionary ContentScriptDetails {
  required DOMString name;
  InjectionItems js;
  InjectionItems css;
  required sequence<(URLPattern or URLPatternInput)> urlPatterns;
  sequence<(URLPattern or URLPatternInput)> excludeURLPatterns;
  boolean allFrames;
  boolean matchAboutBlank;
  RunAt runAt;
};

To fetch an injection item given a controlledframe controlledframe, a USVString urlString, a boolean isCss, a long index, and an algorithm completionSteps that takes a long, a boolean, and a DOMString, run the following steps:

Note: Fetch a classic script cannot be used here because the fetch needs to use controlledframe’s relevant settings object, but the classic script is executed using the embedded navigable’s active document’s relevant settings object.

1. If urlString is not an valid URL string, then:

   1. Run completionSteps given 0, false, and "".

   2. Return.

2. Let request be a new request with the following fields:

   URL

   The result of parsing a URL given urlString and controlledframe’s node document.

   method

   "GET"

   destination

   "style" if isCss is true, "script" otherwise

   client

   controlledframe’s relevant settings object

   mode

   "cors"

3. Fetch request, with processResponseConsumeBody set to the following steps given a response response and a null, failure, or byte sequence contents:

   1. If response’s status is not 200, or contents is null or failure, then run completionSteps given 0, false, and ""

   2. Otherwise, run completionSteps given index, true, and contents.

To validate and resolve ContentScriptDetails given a controlledframe controlledframe and a ContentScriptDetails details, run the following steps:

1. Let result be a new promise.

2. If details["js"] and details["css"] are both defined, or both undefined, then reject result with a TypeError and return it.

3. If details["urlPatterns"] is empty, then reject result with a TypeError and return it.

4. Let isCss be a boolean equal to true if details["css"] is defined, false otherwise.

5. If isCss is true and details["runAt"] does not equal "document-start", then reject result with a TypeError and return it.

6. Let injectionItems be details["css"] if isCss is true, details["js"] otherwise.

7. If injectionItems["code"] and injectionItems["files"] are both defined, or both undefined, reject result with a TypeError and return it.

8. Return result and run the remaining steps in parallel.

9. Let config be a new content script config with the following values:

   pendingFetchCount

   0

   urlPatterns

   «»

   excludeURLPatterns

   «»

   allFrames

   details["allFrames"] if defined, otherwise false

   matchAboutBlank

   details["matchAboutBlank"] if defined, otherwise false

   runAt

   details["runAt"] if defined, otherwise document-idle

10. For each urlPattern in details["urlPatterns"]:

    1. If urlPattern is a URLPattern, then append urlPattern to config’s urlPatterns.

    2. Otherwise, append a new URLPattern given urlPattern to config’s urlPatterns.

11. If details["excludeURLPatterns"] is defined, then:

    1. For each urlPattern in details["excludeURLPatterns"]:

       1. If urlPattern is a URLPattern, then append urlPattern to config’s excludeURLPatterns.

       2. Otherwise, append a new URLPattern given urlPattern to config’s excludeURLPatterns.

12. Let completionSteps be the following algorithm, which takes a long index, a boolean success, and a DOMString source:

    1. If success is false, then reject an embedder promise given controlledframe, result, and TypeError, and abort these steps.

    2. If isCss, then:

       1. Set config’s css[index] to source.

    3. Otherwise:

       1. Set config’s js[index] to source.

    4. Decrement config’s pendingFetchCount.

    5. If config’s pendingFetchCount is greater than 0, then return.

    6. Set controlledframe’s content script map[details[name]] to config.

    7. Resolve an embedder promise given controlledframe and result.

13. If injectionItems["code"] is defined, then:

    1. Run completionSteps given 0, true, and injectionItems ["code"].

14. Otherwise:

    1. If injectionItems["files"] is empty, then reject an embedder promise given controlledframe, result, and TypeError, and abort these steps.

    2. For each urlString of injectionItems ["files"]:

       1. Run fetch an injection item given controlledframe, urlString, isCss, config’s pendingFetchCount, and completionSteps.

       2. Increment config’s pendingFetchCount.

To determine if a content script config applies to a document given a content script config config, a URL url, and a boolean isTopLevel, run the following steps:

1. If isTopLevel is false, and config’s allFrames is false, then return false.

2. If url matches about:blank and config’s matchAboutBlank is false, then return false.

3. Let urlString be the result of serializing url.

4. Let match be false.

5. For each pattern of config’s urlPatterns:

   1. If urlString matches a URLPattern pattern, then set match to true.

6. For each pattern of config’s excludeURLPatterns:

   1. If urlString matches a URLPattern pattern, then set match to false.

7. Return match.

To inject content scripts into a document given a Document document, and a RunAt currentPhase, run the following steps:

1. Let embeddedNavigable be document’s node navigable’s traversable navigable.

2. If embeddedNavigable is null or its embedderParent is null, then return.

3. Let controlledframe be embeddedNavigable’s embedderParent.

4. Let url be document’s URL.

5. Let isTopLevel be true if document’s node navigable’s parent is null, false otherwise.

6. For each config of controlledframe’s content script map:

   1. If the result of determining whether a content script config applies to a document given config, url, and isTopLevel equals false, then continue.

   2. If currentPhase is equal to document-start and config’s css is not empty, then:

      1. For each styleSource of config’s css, run inject a stylesheet into a document given document and styleSource.

   3. Otherwise, if currentPhase equals config’s runAt, then:

      1. For each scriptSource of config’s js, run inject a script into a document given document, scriptSource, and an empty algorithm.

To inject a stylesheet into a document given a Document document and a DOMString styleSource, run the following steps:

1. Let styleSheet be a new CSS style sheet object.

2. Synchronously replace the rules of a CSSStyleSheet given styleSheet and styleSource.

3. Queue a global task on the DOM manipulation task source of document’s global object to add a CSS style sheet given document and styleSheet.

To inject a script into a document given a Document document, a DOMString scriptSource, and an algorithm completionSteps that takes a completion record, run the following steps:

Note: document.currentScript is intentionally not set while executing scriptSource.

1. Let script be the result of creating a classic script given scriptSource, document’s relevant settings object, document’s URL, and the default script fetch options.

2. Queue a global task on the DOM manipulation task source of document’s global object that will run the following steps:

   1. Let completionRecord be the result of running a classic script given script.

   2. Let controlledframe be document’s node navigable’s traversable navigable’s embedderParent.

   3. Queue a global task on the DOM manipulation task source of controlledframe’s relevant global object that will run completionSteps with completionRecord.

The addContentScripts(contentScriptList) method steps are:

1. If contentScriptList is empty, return a new promise that is rejected with a TypeError.

2. Let promises be an empty list.

3. For each contentScript in contentScriptList:

   1. Let promise be the result of calling validate and resolve ContentScriptDetails given contentScript.

   2. Append promise to promises.

4. Return the result of getting a promise for waiting for all promises given promises.

The removeContentScripts(scriptNameList) method steps are:

1. Let result be a new promise.

2. Let controlledframe be this.

3. Return result and run the remaining steps in parallel.

4. If scriptNameList is undefined, then:

   1. Clear controlledframe’s content script map.

5. Otherwise, for each name of scriptNameList:

   1. Remove controlledframe’s content script map[name].

6. Resolve an embedder promise given controlledframe and result.

The executeScript(details) method steps are:

1. Let result be a new promise.

2. Let controlledframe be this.

3. Return result and run the remaining steps in parallel.

4. If controlledframe’s embedded navigable is null, then reject an embedder promise given controlledframe, result, and a TypeError, and abort these steps.

5. If details["code"] and details"[file"] are either both defined or both undefined, then reject an embedder promise given controlledframe, result, and a TypeError, and abort these steps.

6. Let executionSteps be the following algorithm that takes a long and a DOMString or boolean scriptString:

   1. If scriptString is not a DOMString, then reject an embedder promise given controlledframe, result, and a TypeError, and abort these steps.

   2. Let document be controlledframe’s embedded navigable’s active document.

   3. Inject a script into a document given document, scriptString, and the following algorithm that accepts a completion record completionRecord:

      1. If completionRecord is a normal completion, then:

         1. Resolve an embedder promise given controlledframe, result, and completionRecord.[[Value]].

      2. Otherwise:

         1. Reject an embedder promise given controlledframe, result, and completionRecord.[[Value]].

7. If details["code"] is defined, then run executionSteps given 0 and details["code"].

8. Otherwise, fetch an injection item given controlledframe, details["file"], false, 0, and executionSteps.

The insertCSS(details) method steps are:

1. Let result be a new promise.

2. Let controlledframe be this.

3. Return result and run the remaining steps in parallel.

4. If controlledframe’s embedded navigable is null, then reject an embedder promise given controlledframe, result, and a TypeError, and abort these steps.

5. If details["code"] and details["file"] are either both defined or both undefined, then reject an embedder promise given controlledframe, result, and a TypeError, and abort these steps.

6. Let executionSteps be the following algorithm that takes a long, a boolean success, and a DOMString styleString:

   1. If success is false, then reject an embedder promise given controlledframe, result, and a TypeError, and abort these steps.

   2. Let document be controlledframe’s embedded navigable’s active document.

   3. Inject a stylesheet into a document given document and styleString.

   4. Resolve an embedder promise given controlledframe and result.

7. If details["code"] is defined, then run executionSteps given 0, true, and details["code"].

8. Otherwise, fetch an injection item given controlledframe, details["file"], false, 0, and executionSteps.

dictionary ClearDataOptions {
  long since;
};

dictionary ClearDataTypeSet {
  boolean cache;
  boolean cookies;
  boolean fileSystems;
  boolean indexedDB;
  boolean localStorage;
  boolean persistentCookies;
  boolean sessionCookies;
};

To empty a storage bottle given a storage bucket bucket, a storage identifier identifier, and a long since, run the following steps:

Note: If possible, the user agent should only remove data that has been last used after since, which represents a timestamp in milliseconds since epoch. Not all user agents track write or access time for all browsing data. Implementations should respect since to the best of their ability, but the API does not guarantee its availability.

1. Let bottle be bucket[identifier].

2. Clear bottle’s map.

3. Set bottle’s proxy map reference set to a new set.

The clearData(options, types) method steps are:

1. Let resultPromise be a new promise.

2. Let controlledframe be this.

3. Return resultPromise and run the remaining steps in parallel.

4. Let clearSince be 0.

5. If options["since"] is defined, set clearSince to options|["since"].

6. Let embeddingOrigin be the top-level origin of controlledframe’s relevant settings object.

7. Let partition be controlledframe’s partition.

8. For each storageKey → shelf of the user agent’s storage shed:

   1. If storageKey’s embedding origin is not equal to embeddingOrigin or storageKey’s partition is not equal to partition, then continue.

   2. Let bucket be shelf["default"].

   3. If types["fileSystems"] is true:

      1. Empty a storage bottle given bucket, "fileSystem", and clearSince.

   4. If types["indexedDB"] is true:

      1. Empty a storage bottle given bucket, "indexedDB", and clearSince.

   5. If types["localStorage"] is true:

      1. Empty a storage bottle given bucket, "localStorage", and clearSince.

9. If types["cookies"], types["persistentCookies"], or types["sessionCookies"] are true, then:

   The [COOKIES] specification does not support partitioning cookies through a mechanism like storage keys. The following steps will clear all cookies, but the intention is to only delete cookies created by content within a Controlled Frame with this Controlled Frame’s current partition.

   1. For each cookie in the user agent’s cookie store:

      1. If cookie’s persistent-flag is set, then:

         1. If types["cookies"] and types["persistentCookies"] are false, then continue.

      2. Otherwise:

         1. If types["cookies"] and types["sessionCookies"] are false, then continue.

      3. If cookie’s last-access-time represented as milliseconds since the epoch is less than clearSince, then continue.

      4. Remove cookie from the user agent’s cookie store.

10. If types["cache"] is true, then:

    1. For each storageKey → cache that the user agent manages: [HTTP-CACHING]

       1. If storageKey’s embedding origin is not equal to embeddingOrigin or storageKey’s partition is not equal to partition, then continue.

       2. Clear cache.

11. Resolve an embedder promise given controlledframe and resultPromise.

The getAudioState() method steps are:

1. Let resultPromise be a new promise.

2. Let controlledframe be this.

3. Return resultPromise and run the remaining steps in parallel.

4. If controlledframe’s embedded navigable is null, then reject an embedder promise given controlledframe, resultPromise, and a TypeError, and abort these steps.

5. Let playingAudio be true if any content, including in nested frames, within controlledframe’s embedded navigable is currently playing audio, false otherwise.

6. Resolve an embedder promise given controlledframe, resultPromise, and playingAudio.

The isAudioMuted() method steps are:

1. Let resultPromise be a new promise.

2. Let controlledframe be this.

3. Return resultPromise and run the remaining steps in parallel.

4. If controlledframe’s embedded navigable is null, then reject an embedder promise given controlledframe, resultPromise, and a TypeError, and abort these steps.

5. Resolve an embedder promise given controlledframe, resultPromise, and controlledframe’s embedded navigable’s muted flag.

The setAudioMuted(mute) method steps are:

1. If this’s embedded navigable is null, then throw a TypeError.

2. Set this’s embedded navigable’s muted flag to mute.

enum ZoomMode {
  "per-origin",
  "per-view",
  "disabled"
};

To get the per-origin zoom level, given HTMLControlledFrameElement e, run the following steps:

1. Let result be a float initially set to 1.0f.

2. Let key be the result of obtaining a Controlled Frame storage key given the environment associated e’s embedded navigable’s active document’s current settings object.

3. If Controlled Frame zoom map[key] exists, set result to the result of get the value of Controlled Frame zoom map given key key.

4. Return result.

To set the per-origin zoom level, given HTMLControlledFrameElement e, and a float zoomLevel, run the following steps:

1. Let key be the result of obtaining a Controlled Frame storage key given the environment associated e’s embedded navigable’s active document’s current settings object.

2. Set the value of Controlled Frame zoom map given key key and value zoomLevel.

To determine whether current document has a per-origin zoom level, given HTMLControlledFrameElement e, run the following steps:

1. Let key be the result of obtaining a Controlled Frame storage key given the environment associated e’s embedded navigable’s active document’s current settings object.

2. If Controlled Frame zoom map[key] exist, return true.

3. Return false.

The getZoomMode() method steps are:

1. Let p be a new promise.

2. Let controlledframe be this.

3. Return p and run the remaining steps in parallel.

4. Resolve an embedder promise given controlledframe, p, and controlledframe’s zoomMode.

The setZoomMode(zoomMode) method steps are:

1. Let p be a new promise.

2. Let controlledframe be this.

3. Return p and run the remaining steps in parallel.

4. Let currentZoomMode be the result of getZoomMode given controlledframe.

5. If currentZoomMode equals zoomMode, resolve an embedder promise given controlledframe and p.

6. Set controlledframe’s zoomMode to zoomMode.

7. If zoomMode is per-origin:

   1. If current document has a per-origin zoom level given controlledframe is true:

      1. Let oldZoomFactor be controlledframe’s currentZoom.

      2. Set controlledframe’s currentZoom to the result of get the per-origin zoom level given controlledframe.

      3. If oldZoomFactor does not equal to controlledframe’s currentZoom:

         1. Apply zoom level to controlledframe’s embedded document given controlledframe’s currentZoom.

         2. Fire a "zoomchange" event with controlledframe, oldZoomFactor, controlledframe’s currentZoom.

8. If zoomMode is disabled:

   1. Let oldZoomFactor be controlledframe’s currentZoom.

   2. Set controlledframe’s currentZoom to 1.0f.

   3. If oldZoomFactor does not equal to controlledframe’s currentZoom:

      1. Apply zoom level to controlledframe’s embedded document given controlledframe’s currentZoom.

      2. Fire a "zoomchange" event with controlledframe, oldZoomFactor, controlledframe’s currentZoom.

9. Resolve an embedder promise given controlledframe and p.

The getZoom() method steps are:

1. Let p be a new promise.

2. Let controlledframe be this.

3. Return p and run the remaining steps in parallel.

4. Let embeddedNavigable be controlledframe’s embedded navigable.

5. If embeddedNavigable is null, then reject an embedder promise given controlledframe, p, and a TypeError, and abort these steps.

6. Resolve an embedder promise given controlledframe, p, and controlledframe’s currentZoom.

The setZoom(zoomFactor) method steps are:

1. Let p be a new promise.

2. Let controlledframe be this.

3. Return p and run the remaining steps in parallel.

4. Let embeddedNavigable be controlledframe’s embedded navigable.

5. If embeddedNavigable is null, then reject an embedder promise given controlledframe, p, and a TypeError, and abort these steps.

6. If controlledframe’s ZoomMode is disabled:

   1. Reject an embedder promise given controlledframe, p, and a TypeError, and abort these steps.

7. If controlledframe’s ZoomMode is per-origin:

   1. Let oldZoomFactor be controlledframe’s currentZoom.

   2. Set the per-origin zoom level given controlledframe and zoomFactor.

   3. For each browsing context group group in the user agent’s browsing context group set:

      1. For each top-level browsing context browsingContext in group:

         1. Let embeddedDocument be browsingContext’s active document.

         2. Let embedder be embeddedDocument’s node navigable’s embedderParent.

         3. If embedder is null, then continue.

         4. Let match be true if all of the following conditions are true:

            • embedder’s ZoomMode is per-origin

            • embedder’s partition equals controlledframe’s partition

            • embeddedDocument’s origin equals controlledframe’s embedded navigable’s active document’s origin

            • embedder’s currentZoom does not equal zoomFactor

         5. If match is true, then:

            1. Set embedder’s currentZoom to zoomFactor.

            2. Apply zoom level to embeddedDocument given zoomFactor.

            3. Fire a "zoomchange" event with embedder, oldZoomFactor, and zoomFactor.

8. If controlledframe’s ZoomMode is per-view:

   1. Let oldZoomFactor be controlledframe’s currentZoom.

   2. Set controlledframe’s currentZoom to zoomFactor.

   3. If oldZoomFactor does not equal to controlledframe’s currentZoom:

      1. Apply zoom level to controlledframe’s embedded document given controlledframe’s currentZoom.

      2. Fire a "zoomchange" event with controlledframe, oldZoomFactor, controlledframe’s currentZoom.

9. Resolve an embedder promise given controlledframe and p.

// One of |code| or |file| must be specified but not both.
dictionary ImageDetails {
  DOMString format;
  DOMString quality;
};

The captureVisibleRegion(options) method steps are:

1. Let resultPromise be a new promise.

2. Let controlledframe be this.

3. Return resultPromise and run the remaining steps in parallel.

4. If controlledframe’s embedded navigable is null, then reject an embedder promise given controlledframe, resultPromise, and a TypeError, and abort these steps.

5. Let optionsFormat be "JPEG" by default.

6. Let optionsQuality be 100 by default.

7. If options has field "format":

   1. Let optionsFormat be options["format"].

8. If optionsFormat is an unrecognized format, then reject an embedder promise given controlledframe, resultPromise, and a TypeError, and abort these steps.

9. If options has field "quality":

   1. Let optionsQuality be options["quality"].

10. If optionsQuality is not an integer or is not between 0 and 100 inclusive, then reject an embedder promise given controlledframe, resultPromise, and a TypeError, and abort these steps.

11. Let imageData be a an image showing the visible region of the embedded content encoded in optionsFormat at quality optionsQuality.

    Note: The set of supported image formats is implementation-defined, but it is recommended to support at least "JPEG" and "PNG".

12. Resolve an embedder promise given controlledframe, resultPromise, and a data: URL that contains imageData.

The print() method steps are:

1. If this’s embedded navigable is null, then throw a TypeError.

2. Initiate the browser print page feature for embedded content.

[Exposed=Window, IsolatedContext]
interface ConsoleMessage {
  readonly attribute long level;
  readonly attribute DOMString message;
};

[Exposed=Window, IsolatedContext]
interface ConsoleMessageEvent : Event {
  constructor(DOMString type, optional ConsoleMessageEventInit eventInitDict = {});
  readonly attribute ConsoleMessage consoleMessage;
};

dictionary ConsoleMessageEventInit: EventInit {
  ConsoleMessage? consoleMessage;
};

To fire a ConsoleMessageEvent e given controlledframe element target, a long logLevel and a DOMString message, run the following steps:

1. Let consoleMessage be a new ConsoleMessage object.

2. Set the following fields of consoleMessage:

   level

   logLevel.

   message

   message.

3. Set e’s consoleMessage to consoleMessage.

4. Queue a global task on the DOM manipulation task source of target’s relevant global object to dispatch e at target.

enum DialogType {
  "alert",
  "confirm",
  "prompt"
};

[Exposed=Window, IsolatedContext]
interface DialogController {
  undefined okay(optional DOMString response);
  undefined cancel();
};

[Exposed=Window, IsolatedContext]
interface DialogMessage {
  readonly attribute DialogType messageType;
  readonly attribute DOMString messageText;
  readonly attribute DialogController dialog;
};

[Exposed=Window, IsolatedContext]
interface DialogEvent : Event {
  constructor(DOMString type, optional DialogEventInit eventInitDict = {});
  readonly attribute DialogMessage dialogMessage;
};

dictionary DialogEventInit: EventInit {
  DialogMessage? dialogMessage;
};

To fire a DialogEvent e given controlledframe element target, simple-dialogs type dialogType, and message message, run the following steps:

1. Assert that e["dialogMessage"]["dialog"]["accept"] equals false.

2. Let dialogMessage be a new DialogMessage object.

3. Let dialog be a new DialogController object.

4. Set the following fields of dialogMessage:

   messageType

   dialogType.

   messageText

   message.

   dialog

   dialog.

5. Set e’s dialogMessage to dialogMessage.

6. Let complete be false.

7. Queue a global task on the DOM manipulation task source of target’s relevant global object to run the following steps:

   1. Dispatch e at target.

   2. Set complete to true.

8. Synchronously wait for complete to be true.

   Note: Blocking here is intentional as the alert, confirm, and prompt dialogs represented by "dialog" events block the main thread, and the event handlers we’re calling here can affect the return values.

9. Return e["dialogMessage"]["dialog"]["accept"] and e["dialogMessage"]["dialog"]["response"].

enum WindowOpenDisposition {
  "ignore",
  "save_to_disk",
  "current_tab",
  "new_background_tab",
  "new_foreground_tab",
  "new_window",
  "new_popup"
};

[Exposed=Window, IsolatedContext]
interface NewWindowController {
  undefined attach(HTMLControlledFrameElement newControlledFrame);
  undefined discard();
};

[Exposed=Window, IsolatedContext]
interface NewWindow {
  readonly attribute NewWindowController window;
  readonly attribute USVString targetUrl;
  readonly attribute DOMString name;
  readonly attribute WindowOpenDisposition windowOpenDisposition;
};

[Exposed=Window, IsolatedContext]
interface NewWindowEvent : Event {
  constructor(DOMString type, optional NewWindowEventInit eventInitDict = {});
  readonly attribute NewWindow newWindow;
};

dictionary NewWindowEventInit: EventInit {
  NewWindow? newWindow;
};

To fire a NewWindowEvent e given controlledframe element controlledFrame, USVString url, DOMString target, navigable targetNavigable, and WindowOpenDisposition windowOpenDisposition, run the following steps:

1. Let controller be a new NewWindowController object.

2. Set controller’s target navigable to targetNavigable.

3. Let newWindow be a new NewWindow object.

4. Set the following fields of newWindow:

   window

   controller

   targetUrl

   url

   name

   target.

   windowOpenDisposition

   windowOpenDisposition

5. Set e’s newWindow to newWindow.

6. Queue a global task on the DOM manipulation task source of controlledFrame’s relevant global object to dispatch e at controlledFrame.

enum PermissionType {
  "media",
  "geolocation",
  "pointerLock",
  "download",
  "filesystem",
  "fullscreen",
  "hid",
};

[Exposed=Window, IsolatedContext]
interface PermissionRequestControllerBase {
  undefined allow();
  undefined cancel();
};

[Exposed=Window, IsolatedContext]
interface MediaPermissionRequestController: PermissionRequestControllerBase {
  readonly attribute USVString url;
};

[Exposed=Window, IsolatedContext]
interface GeolocationPermissionRequestController: PermissionRequestControllerBase {
  readonly attribute USVString url;
};

[Exposed=Window, IsolatedContext]
interface PointerLockPermissionRequestController: PermissionRequestControllerBase {
  readonly attribute boolean lastUnlockedBySelf;
  readonly attribute boolean userGesture;
  readonly attribute USVString url;
};

[Exposed=Window, IsolatedContext]
interface DownloadPermissionRequestController : PermissionRequestControllerBase {
  readonly attribute DOMString requestMethod;
  readonly attribute USVString url;
};

[Exposed=Window, IsolatedContext]
interface FileSystemPermissionRequestController : PermissionRequestControllerBase {
  readonly attribute USVString url;
};

[Exposed=Window, IsolatedContext]
interface FullscreenPermissionRequestController : PermissionRequestControllerBase {
  readonly attribute USVString origin;
};

[Exposed=Window, IsolatedContext]
interface HidPermissionRequestController : PermissionRequestControllerBase {
  readonly attribute USVString url;
};

[Exposed=Window, IsolatedContext]
interface PermissionRequest {
  readonly attribute PermissionType permission;
  readonly attribute PermissionRequestControllerBase request;
};

[Exposed=Window, IsolatedContext]
interface PermissionRequestEvent : Event {
  constructor(DOMString type, optional PermissionRequestEventInit eventInitDict = {});
  readonly attribute PermissionRequest permissionRequest;
};

dictionary PermissionRequestEventInit: EventInit {
  PermissionRequest? permissionRequest;
};

To fire a PermissionRequestEvent e given a document embeddedDocument, controlledframe element target, DOMString type, USVString url, an optional dictionary options, and an algorithm completionSteps that takes a boolean, run the following steps:

1. Let permissionRequest be a new PermissionRequest object.

2. If type is "media":

   1. Let requestController be a new MediaPermissionRequestController with the following attributes:

      url

      url

3. If type is "geolocation":

   1. Let requestController be a new GeolocationPermissionRequestController with the following attributes:

      url

      url

4. If type is "pointerLock":

   1. Let requestController be a new PointerLockPermissionRequestController with the following attributes:

      lastUnlockedBySelf

      options["lastUnlockedBySelf"]

      userGesture

      options["userGesture"]

      url

      url

5. If type is "download":

   1. Let requestController be a new DownloadPermissionRequestController with the following attributes:

      requestMethod

      options["requestMethod"]

      url

      url

6. If type is "filesystem":

   1. Let requestController be a new FileSystemPermissionRequestController with the following attributes:

      url

      url

7. If type is "fullscreen":

   1. Let requestController be a new FullscreenPermissionRequestController with the following attributes:

      origin

      origin of url

8. If type is "hid":

   1. Let requestController be a new HidPermissionRequestController with the following attributes:

      url

      url

9. Set the following fields of permissionRequest:

   request

   requestController

   permission

   type.

10. Set e’s permissionRequest to permissionRequest.

11. Queue a global task on the DOM manipulation task source of target’s relevant global object to run the following steps:

    1. Dispatch e at target.

    2. Queue a global task on the DOM manipulation task source of embeddedDocument’s relevant global object that runs completionSteps with e["permissionRequest"]["permission"]["allow"].

[Exposed=Window, IsolatedContext]
interface SizeChange {
  readonly attribute unsigned long oldWidth;
  readonly attribute unsigned long oldHeight;
  readonly attribute unsigned long newWidth;
  readonly attribute unsigned long newHeight;
};

[Exposed=Window, IsolatedContext]
interface SizeChangedEvent : Event {
  constructor(DOMString type, optional SizeChangedEventInit eventInitDict = {});
  readonly attribute SizeChange sizeChange;
};

dictionary SizeChangedEventInit: EventInit {
  SizeChange? sizeChange;
};

To fire a SizeChangedEvent e given controlledframe element target, 4 non-negative numbers oldWidth, oldHeight, newWidth, newHeight:

1. Let sizeChange be a new SizeChange object.

2. Set the following fields of sizeChange:

   oldWidth

   oldWidth.

   oldHeight

   oldHeight.

   newWidth

   newWidth.

   newHeight

   newHeight.

3. Set e’s sizeChange to sizeChange.

4. Queue a global task on the DOM manipulation task source of target’s relevant global object to dispatch e at target.

[Exposed=Window, IsolatedContext]
interface ZoomChange {
  readonly attribute float oldZoomFactor;
  readonly attribute float newZoomFactor;
};

[Exposed=Window, IsolatedContext]
interface ZoomChangeEvent : Event {
  constructor(DOMString type, optional ZoomChangeEventInit eventInitDict = {});
  readonly attribute ZoomChange zoomChange;
};

dictionary ZoomChangeEventInit: EventInit {
  ZoomChange? zoomChange;
};

To fire a ZoomChangeEvent e given controlledframe element target, 2 float numbers oldZoomFactor, newZoomFactor:

1. Let zoomChange be a new ZoomChange object.

2. Set the following fields of zoomChange:

   oldZoomFactor

   oldZoomFactor.

   newZoomFactor

   newZoomFactor.

3. Set e’s zoomChange to zoomChange.

4. Queue a global task on the DOM manipulation task source of target’s relevant global object to dispatch e at target.

[Exposed=Window, IsolatedContext]
interface ContentLoadEvent : Event {
  constructor(DOMString type, optional EventInit eventInitDict = {});
};

To fire a ContentLoadEvent e given controlledframe element target, run the following steps:

1. Queue a global task on the DOM manipulation task source of target’s relevant global object to dispatch e at target.

[Exposed=Window, IsolatedContext]
interface LoadInfo {
  readonly attribute USVString url;
  readonly attribute boolean isTopLevel;
};

[Exposed=Window, IsolatedContext]
interface LoadAbortInfo : LoadInfo{
  readonly attribute long code;
  readonly attribute DOMString reason;
};

[Exposed=Window, IsolatedContext]
interface LoadRedirectInfo{
  readonly attribute USVString oldUrl;
  readonly attribute USVString newUrl;
  readonly attribute boolean isTopLevel;
};

[Exposed=Window, IsolatedContext]
interface LoadAbortEvent : Event {
  constructor(DOMString type, optional LoadAbortEventInit eventInitDict = {});
  readonly attribute LoadAbortInfo loadAbortInfo;
};

dictionary LoadAbortEventInit: EventInit {
  LoadAbortInfo? loadAbortInfo;
};

To fire a LoadAbortEvent e given controlledframe element target, a USVString url, a boolean isTopLevel, a long code, and a DOMString reason, run the following steps:

1. Let info be a new LoadAbortInfo with the following attributes:

   url

   url

   isTopLevel

   isTopLevel

   code

   code

   reason

   reason

2. Set e’s loadAbortInfo to info.

3. Queue a global task on the DOM manipulation task source of target’s relevant global object to dispatch e at target.

[Exposed=Window, IsolatedContext]
interface LoadCommitEvent : Event {
  constructor(DOMString type, optional LoadCommitEventInit eventInitDict = {});
  readonly attribute LoadInfo loadInfo;
};

dictionary LoadCommitEventInit: EventInit {
  LoadInfo? loadInfo;
};

To fire a LoadCommitEvent e given controlledframe element target, a USVString url, and a boolean isTopLevel, run the following steps:

1. Let info be a new LoadInfo with the following attributes:

   url

   url

   isTopLevel

   isTopLevel

2. Set e’s loadInfo to info.

3. Queue a global task on the DOM manipulation task source of target’s relevant global object to dispatch e at target.

[Exposed=Window, IsolatedContext]
interface LoadStartEvent : Event {
  constructor(DOMString type, optional LoadStartEventInit eventInitDict = {});
  readonly attribute LoadInfo loadInfo;
};

dictionary LoadStartEventInit: EventInit {
  LoadInfo? loadInfo;
};

To fire a LoadStartEvent e given controlledframe element target, a USVString url, and a boolean isTopLevel, run the following steps:

1. Let info be a new LoadInfo with the following attributes:

   url

   url

   isTopLevel

   isTopLevel

2. Set e’s loadInfo to info.

3. Queue a global task on the DOM manipulation task source of target’s relevant global object to dispatch e at target.

[Exposed=Window, IsolatedContext]
interface LoadStopEvent : Event {
  constructor(DOMString type, optional LoadStopEventInit eventInitDict = {});
};

dictionary LoadStopEventInit: EventInit {
};

To fire a LoadStopEvent e given controlledframe element target, run the following steps:

1. Queue a global task on the DOM manipulation task source of target’s relevant global object to dispatch e at target.

[Exposed=Window, IsolatedContext]
interface LoadRedirectEvent : Event {
  constructor(DOMString type, optional LoadRedirectEventInit eventInitDict = {});
  readonly attribute LoadRedirectInfo loadRedirectInfo;
};

dictionary LoadRedirectEventInit: EventInit {
  LoadRedirectInfo? loadRedirectInfo;
};

To fire a LoadRedirectEvent e given controlledframe element target, an URL oldUrl, an URL newUrl, and a boolean isTopLevel, run the following steps:

1. Let info be a new LoadInfo with the following attributes:

   oldUrl

   The result of serializing an URL given oldUrl

   newUrl

   The result of serializing an URL given newUrl

   isTopLevel

   isTopLevel

2. Set e’s loadRedirectInfo to info.

3. Queue a global task on the DOM manipulation task source of target’s relevant global object to dispatch e at target.

To determine if a Document document is allowed by embedder to use a permission given DOMString permission, an optional dictionary options, and an algorithm completionSteps that takes a boolean, run the following steps:

1. Let embedderParent be document’s node navigable’s embedderParent.

2. If embedderParent is not HTMLControlledFrameElement, return true.

3. Fire a "permissionrequest" event with document, embedderParent, permission, document’s URL, options, and completionSteps.

To determine the network partition key, given an environment environment:

4. Let topLevelSite be the result of obtaining a site, given topLevelOrigin.

5. Let secondKey be null or an implementation-defined value .

6. Let embedderParent be the result of getting an environment’s embedderParent given environment.
7. If embedderParent is not null, then set secondKey to a tuple consisting of the top-level origin of embedderParent’s relevant settings object, and embedderParent’s partition.

8. Return (topLevelSite, secondKey).

To obtain a storage key for non-storage purposes, given an environment environment, run these steps:

1. Let origin be environment’s origin if environment is an environment settings object; otherwise environment’s creation URL’s origin.

2. Return a tuple consisting of origin.
3. Let topLevelOrigin and partition be null.
4. Let embedderParent be the result of getting an environment’s embedderParent given environment.
5. If embedderParent is not null, then:
   1. Set topLevelOrigin to the top-level origin of embedderParent’s relevant settings object.
   2. Set partition to embedderParent’s partition.
6. Return a tuple consisting of topLevelOrigin, partition, and origin.

To get an environment’s embedderParent given an environment environment, run the following steps:

1. If environment is an environment settings object whose global object is a Window object, then:

   This algorithm doesn’t work for Shared or Service Workers because embedderParent is only defined on a navigable, and it’s not always possible to go from a non-Window environment to a navigable.

   1. Let navigable be environment’s global object’s navigable.

   2. Let top be the top-level traversable of navigable.

   3. If top’s embedderParent is not null, then return top’s embedderParent.

2. Return null.

enum ResourceType {
  "main-frame",
  "sub-frame",
  "stylesheet",
  "script",
  "image",
  "font",
  "object",
  "xmlhttprequest",
  "ping",
  "csp-report",
  "media",
  "websocket",
  "other",
};

enum RequestedHeaders {
  "none",
  "cors",
  "all",
};

dictionary WebRequestInterceptorOptions {
  required sequence<(URLPattern or URLPatternInput)> urlPatterns;
  sequence<ResourceType> resourceTypes = [];
  boolean blocking = false;
  boolean includeRequestBody = false;
  RequestedHeaders includeHeaders = "none";
};

[Exposed=Window, IsolatedContext]
interface WebRequest {
  WebRequestInterceptor createWebRequestInterceptor(
      WebRequestInterceptorOptions options);

  Promise<undefined> interceptorBehaviorChanged();
};

[Exposed=Window, IsolatedContext]
interface WebRequestInterceptor : EventTarget {
  attribute EventHandler onauthrequired;
  attribute EventHandler onbeforeredirect;
  attribute EventHandler onbeforerequest;
  attribute EventHandler onbeforesendheaders;
  attribute EventHandler oncompleted;
  attribute EventHandler onerroroccurred;
  attribute EventHandler onheadersreceived;
  attribute EventHandler onsendheaders;
  attribute EventHandler onresponsestarted;
};

enum DocumentLifecycle {
  "prerender",
  "active",
  "cached",
  "pending-deletion",
};

enum FrameType {
  "outermost-frame",
  "fenced-frame",
  "sub-frame",
};

[Exposed=Window, IsolatedContext]
interface UploadData {
  readonly attribute ArrayBuffer? bytes;
  readonly attribute DOMString? file;
};

[Exposed=Window, IsolatedContext]
interface RequestBody {
  readonly attribute DOMString? error;
  readonly attribute any formData;
  readonly attribute FrozenArray<UploadData>? raw;
};

[Exposed=Window, IsolatedContext]
interface WebRequestRequest {
  readonly attribute DOMString method;
  readonly attribute DOMString id;
  readonly attribute ResourceType type;
  readonly attribute USVString url;
  readonly attribute USVString? initiator;
  readonly attribute Headers? headers;
  readonly attribute RequestBody? body;
};

[Exposed=Window, IsolatedContext]
interface AuthChallenger {
  readonly attribute DOMString host;
  readonly attribute long port;
};

[Exposed=Window, IsolatedContext]
interface WebRequestAuthDetails {
  readonly attribute AuthChallenger challenger;
  readonly attribute boolean isProxy;
  readonly attribute DOMString scheme;
  readonly attribute DOMString? realm;
};

[Exposed=Window, IsolatedContext]
interface WebRequestResponse {
  readonly attribute long statusCode;
  readonly attribute DOMString statusLine;
  readonly attribute boolean fromCache;
  readonly attribute Headers? headers;
  readonly attribute DOMString? ip;
  readonly attribute USVString? redirectURL;
  readonly attribute WebRequestAuthDetails? auth;
};

[Exposed=Window, IsolatedContext]
interface WebRequestEvent : Event {
  readonly attribute WebRequestRequest request;
  readonly attribute long frameId;
  readonly attribute FrameType? frameType;
  readonly attribute DOMString? documentId;
  readonly attribute DocumentLifecycle? documentLifecycle;
  readonly attribute DOMString? parentDocumentId;
  readonly attribute long? parentFrameId;
};

dictionary WebRequestAuthCredentials {
  required DOMString username;
  required DOMString password;
};

dictionary WebRequestAuthOptions {
  AbortSignal signal;
};

[Exposed=Window, IsolatedContext]
interface WebRequestAuthRequiredEvent : WebRequestEvent {
  readonly attribute WebRequestResponse response;

  undefined setCredentials(
    Promise<WebRequestAuthCredentials> credentials,
    optional WebRequestAuthOptions options = {});
};

[Exposed=Window, IsolatedContext]
interface WebRequestBeforeRedirectEvent : WebRequestEvent {
  readonly attribute WebRequestResponse response;
};

[Exposed=Window, IsolatedContext]
interface WebRequestBeforeRequestEvent : WebRequestEvent {
  undefined redirect(USVString redirectURL);
};

[Exposed=Window, IsolatedContext]
interface WebRequestBeforeSendHeadersEvent : WebRequestEvent {
  undefined setRequestHeaders((Headers or HeadersInit) requestHeaders);
};

[Exposed=Window, IsolatedContext]
interface WebRequestCompletedEvent : WebRequestEvent {
  readonly attribute WebRequestResponse response;
};

[Exposed=Window, IsolatedContext]
interface WebRequestErrorOccurredEvent : WebRequestEvent {
  readonly attribute DOMString error;
};

[Exposed=Window, IsolatedContext]
interface WebRequestHeadersReceivedEvent : WebRequestEvent {
  readonly attribute WebRequestResponse response;

  undefined redirect(USVString redirectURL);
  undefined setResponseHeaders((Headers or HeadersInit) responseHeaders);
};

[Exposed=Window, IsolatedContext]
interface WebRequestResponseStartedEvent : WebRequestEvent {
  readonly attribute WebRequestResponse response;
};

[Exposed=Window, IsolatedContext]
interface WebRequestSendHeadersEvent : WebRequestEvent {};

The createWebRequestInterceptor(options) method steps are:

1. Let interceptor be a new WebRequestInterceptor object.

2. Set the following fields on interceptor:

   resourceTypes

   options["resourceTypes"]

   blocking

   options["blocking"]

   includeRequestBody

   options["includeRequestBody"]

   includeHeaders

   options["includeHeaders"]

3. For each urlPattern in options["urlPatterns"]:

   1. If urlPattern is a URLPattern, then append urlPattern to interceptor’s urlPatterns.

   2. Otherwise, append a new URLPattern given urlPattern to interceptor’s urlPatterns.

4. Append interceptor to this’s interceptors.

5. Return interceptor.

The interceptorBehaviorChanged(callback) method steps are:

1. Let controlledframe be this.

2. In parallel, clear the HTTP cache associated with the partition used by environments embedded within the controlledframe HTMLControlledFrameElement.

   Note: The behavior of event handlers registered through the WebRequest API will be reflected in the HTTP cache, which will no longer be valid if the behavior of the event handlers changed. The purpose of this method is to invalidate any cache entries that were affected by WebRequest event handlers.

3. Invoke callback when the HTTP cache has been cleared.

To get the applicable WebRequestInterceptors for a request request, run the following steps:

1. Let client be request’s client.

2. If client is null, return an empty list and false.

3. Let window be the owning Window of an environment settings object given client.

4. If window is null then return an empty list and false.

5. Let navigable be window’s node navigable.

6. If navigable’s embedderParent is null, return an empty list and false.

7. Let controlledFrame be the HTMLControlledFrameElement corresponding to navigable’s embedderParent.

8. Let applicableInterceptors be an empty list.

9. Let blocking be false.

10. For each interceptor in controlledFrame’s request’s interceptors:

    1. If request should not be intercepted by interceptor, then continue.

    2. Append interceptor to applicableInterceptors.

    3. If interceptor’s blocking is true, then set blocking to true.

11. Return applicableInterceptors and blocking.

To determine if a request request should be intercepted by a WebRequestInterceptor, run the following steps:

1. Let types be interceptor’s resourceTypes.

2. If types is not empty and types does not contain the result of calling get a request’s ResourceType given request, then return false.

3. Let urlPatterns be interceptor’s urlPatterns.

4. For each urlPattern in urlPatterns:

   1. If request’s URL matches a URLPattern given urlPattern, then return true.

5. Return false.

To get the owning Window of an environment settings object given an environment settings object environment, run the following steps:

1. Let global be environment’s global object.

2. If global is a Window object, then return global.

3. If global is a DedicatedWorkerGlobalScope object, then:

   1. Let owner be global.

   2. While owner is a DedicatedWorkerGlobalScope object:

      1. Let owner be owner’s owner set[0].

   3. If owner is a Document object, then return owner’s relevant global object.

4. Return null.

WebRequestAuthRequiredEvent’s setCredentials(credentials, options) method steps are:

1. Set this’s authCredentials to credentials.

2. Set this’s options to options.

WebRequestAuthRequiredEvent’s preventDefault() method steps are to set this’s cancel to true.

WebRequestBeforeRequestEvent’s redirect(redirectURL) method steps are to set this’s redirectURL to redirectURL.

WebRequestBeforeRequestEvent’s preventDefault() method steps are to set this’s cancel to true.

WebRequestBeforeSendHeadersEvent’s setRequestHeaders(requestHeaders) method steps are to set this’s requestHeaders to requestHeaders.

WebRequestBeforeSendHeadersEvent’s preventDefault() method steps are to set this’s cancel to true.

WebRequestHeadersReceivedEvent’s redirect(redirectURL) method steps are to set this’s redirectURL to redirectURL.

WebRequestHeadersReceivedEvent’s setResponseHeaders(responseHeaders) method steps are to set this’s responseHeaders to responseHeaders.

WebRequestHeadersReceivedEvent’s preventDefault() method steps are to set this’s cancel to true.

To process beforeRequest events given a request request, run the following steps:

1. Let interceptors and blocking be the result of getting the applicable WebRequestInterceptors of request.

2. Let result be a WebRequestEvent result.

3. Let pendingHandlerCount be interceptor’s size.

4. Let embedderGlobal be the relevant global object of the result of getting an environment’s embedderParent given request’s client.

5. For each interceptor in interceptors:

   1. Let event be a new WebRequestBeforeRequestEvent named beforerequest.

   2. Populate a WebRequestEvent given event, request, and "none".

   3. If interceptor’s includeRequestBody is true and request’s body is not null, then:

      1. Let requestBody be a new RequestBody.

      2. Let body be request’s body.

         TODO: serialize stream if present.

      3. Switch on body’s source:

         byte sequence

         Append a new UploadData with bytes equal to the serialized body’s source to requestBody’s raw.

         Blob

         Append a new UploadData with bytes equal to the serialized body’s source to requestBody’s raw.

         FormData

         1. Let formData be «[]».

         2. For each entry in body’s source’s entry list:

            1. Switch on entry[1]:

            File

            Append a new UploadData with file equal to entry[1]'s name to requestBody’s raw.

            USVString

            1. If formData[entry[0]] does not exist, then set formData[entry[0]] equal to an empty list.

            2. Append entry[1] to formData[entry[0]].

         3. Set requestBody’s formData to formData.

      4. Set event’s request’s body to requestBody.

   4. Queue a global task on the DOM manipulation task source of embedderGlobal that will run the following steps:

      1. Dispatch event to interceptor.

      2. If event’s cancel is true, then set result’s cancel to true.

      3. If event’s redirectURL is not null and result’s redirectURL is "", then set result’s redirectURL to event’s redirectURL.

      4. Decrement pendingHandlerCount.

6. If blocking is true, then wait in parallel for pendingHandlerCount to equal 0, then queue a global task on the networking task source of request’s client’s global object that will continue the remaining steps of this algorithm.

7. Return result.

To process beforeSendHeaders events given a request request, run the following steps:

1. Let interceptors and blocking be the result of getting the applicable WebRequestInterceptors of request.

2. Let result be a WebRequestEvent result.

3. Let pendingHandlerCount be interceptor’s size.

4. Let embedderGlobal be the relevant global object of the result of getting an environment’s embedderParent given request’s client.

5. For each interceptor in interceptors:

   1. Let event be a new WebRequestBeforeSendHeadersEvent named beforesendheaders.

   2. Populate a WebRequestEvent given event, request, and interceptor’s includeHeaders.

   3. Queue a global task on the DOM manipulation task source of embedderGlobal that will run the following steps:

      1. Dispatch event to interceptor.

      2. If event’s cancel is true, then set result’s cancel to true.

      3. If event’s requestHeaders is not null, then:

         1. If result’s requestHeaders is null, then set it to a new Headers.

         2. For each header in event’s requestHeaders:

            1. Append header to result’s requestHeaders.

      4. Decrement pendingHandlerCount.

6. If blocking is true, then wait in parallel for pendingHandlerCount to equal 0, then queue a global task on the networking task source of request’s client’s global object that will continue the remaining steps of this algorithm.

7. Return result.