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. Let webRequest be a new WebRequest.

2. Let onBeforeRequest be a new WebRequestEvent with the following fields:

   eventName

   "beforeRequest"

   webRequest

   webRequest

3. Set webRequest’s onBeforeRequest to onBeforeRequest.

4. Let onBeforeSendHeaders be a new WebRequestEvent with the following fields:

   eventName

   "beforeSendHeaders"

   webRequest

   webRequest

5. Set webRequest’s onBeforeSendHeaders to onBeforeSendHeaders.

6. Let onSendHeaders be a new WebRequestEvent with the following fields:

   eventName

   "sendHeaders"

   webRequest

   webRequest

7. Set webRequest’s onSendHeaders to onSendHeaders.

8. Let onHeadersReceived be a new WebRequestEvent with the following fields:

   eventName

   "headersReceived"

   webRequest

   webRequest

9. Set webRequest’s onHeadersReceived to onHeadersReceived.

10. Let onAuthRequired be a new WebRequestEvent with the following fields:

    eventName

    "authRequired"

    webRequest

    webRequest

11. Set webRequest’s onAuthRequired to onAuthRequired.

12. Let onBeforeRedirect be a new WebRequestEvent with the following fields:

    eventName

    "beforeRedirect"

    webRequest

    webRequest

13. Set webRequest’s onBeforeRedirect to onBeforeRedirect.

14. Let onResponseStarted be a new WebRequestEvent with the following fields:

    eventName

    "responseStarted"

    webRequest

    webRequest

15. Set webRequest’s onResponseStarted to onResponseStarted.

16. Let onCompleted be a new WebRequestEvent with the following fields:

    eventName

    "completed"

    webRequest

    webRequest

17. Set webRequest’s onCompleted to onCompleted.

18. Let onErrorOccurred be a new WebRequestEvent with the following fields:

    eventName

    "errorOccurred"

    webRequest

    webRequest

19. Set webRequest’s onErrorOccurred to onErrorOccurred.

20. Set this’s request to webRequest.

21. Let contextMenus be a new ContextMenus.

22. Let onClicked be a new OnClickedEvent.

23. Set contextMenus’s onClicked to onClicked.

24. Let onShow be a new OnShowEvent.

25. Set contextMenus’s onShow to onShow.

26. Set this’s contextMenus to 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 USVString url matches a match pattern pattern if the following steps return true:

Match patterns should have a formal specification. Documentation exists on MDN, and all browsers that support Web Extensions will already have a Match Pattern implementation that can be reused here.

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:

We can’t actually synchronously access the embedded navigable’s history state. In the future we should update this method to return a Promise.

1. If this’s embedded navigable is null, then return false.

2. If this’s embedded navigable’s current session history step is > 0, return true.

3. Return false.

The canGoForward() method steps are:

1. If this’s embedded navigable is null, then return false.

2. Let step be this’s embedded navigable’s current session history step.

3. Let steps be the result of getting all used history steps given this’s embedded navigable.

4. If step + 1 < the size of steps, then return true.

5. Return false.

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<DOMString> matches;
  sequence<DOMString> excludeMatches;
  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["matches"] 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

   matches

   details["matches"]

   excludeMatches

   details["excludeMatches"] if defined, otherwise an empty list

   allFrames

   details["allFrames"] if defined, otherwise false

   matchAboutBlank

   details["matchAboutBlank"] if defined, otherwise false

   runAt

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

10. 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.

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

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

12. 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 matches:

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

6. For each pattern of config’s excludeMatches:

   1. If urlString matches a match pattern 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",
};

callback interface WebRequestEventListener {
  BlockingResponse? handleEvent(WebRequestEventDetails details);
};

dictionary RequestFilter {
  sequence<ResourceType> types;
  sequence<USVString> urls;
};

enum ExtraInfoSpec {
  "asyncBlocking",
  "blocking",
  "extraHeaders",
  "requestHeaders",
  "responseHeaders",
};

[Exposed=Window, IsolatedContext]
interface WebRequestEvent {
  undefined addListener(WebRequestEventListener listener,
                        optional RequestFilter filter = {},
                        optional sequence<ExtraInfoSpec> extraInfoSpec);
  boolean hasListener(WebRequestEventListener listener);
  boolean hasListeners();
  undefined removeListener(WebRequestEventListener listener);
};

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

dictionary BlockingResponse {
  WebRequestAuthCredentials authCredentials;
  boolean cancel;
  USVString redirectUrl;
  sequence<HttpHeader> requestHeaders;
  sequence<HttpHeader> responseHeaders;
};

enum DocumentLifecycle {
  "prerender",
  "active",
  "cached",
  "pending_deletion",
};

enum FrameType {
  "outermost_frame",
  "fenced_frame",
  "sub_frame",
};

dictionary WebRequestEventDetails {
  DOMString documentId;
  DocumentLifecycle documentLifecycle;
  required long frameId;
  FrameType frameType;
  USVString initiator;
  required DOMString method;
  DOMString parentDocumentId;
  required long parentFrameId;
  required DOMString requestId;
  required long timeStamp;
  required ResourceType type;
  required USVString url;
};

dictionary UploadData {
  ArrayBuffer bytes;
  DOMString file;
};

dictionary RequestBody {
  DOMString error;
  any formData;
  sequence<UploadData> raw;
};

dictionary WebRequestBeforeRequestDetails : WebRequestEventDetails {
  RequestBody requestBody;
};

dictionary HttpHeader {
  required DOMString name;
  DOMString value;
  sequence<byte> binaryValue;
};

dictionary WebRequestBeforeSendHeadersDetails : WebRequestEventDetails {
  sequence<HttpHeader> requestHeaders;
};

dictionary WebRequestSendHeadersDetails : WebRequestEventDetails {
  sequence<HttpHeader> requestHeaders;
};

dictionary WebRequestResponseEventDetails : WebRequestEventDetails {
  required long statusCode;
  required DOMString statusLine;
  sequence<HttpHeader> responseHeaders;
};

dictionary WebRequestHeadersReceivedDetails : WebRequestResponseEventDetails {};

dictionary AuthChallenger {
  DOMString host;
  long port;
};

dictionary WebRequestAuthRequiredDetails : WebRequestResponseEventDetails {
  required AuthChallenger challenger;
  required boolean isProxy;
  required DOMString scheme;
  DOMString realm;
};

dictionary WebRequestResponseWithIpEventDetails : WebRequestResponseEventDetails {
  required boolean fromCache;
  DOMString ip;
};

dictionary WebRequestBeforeRedirectDetails : WebRequestResponseWithIpEventDetails {
  required USVString redirectUrl;
};

dictionary WebRequestResponseStartedDetails : WebRequestResponseWithIpEventDetails {};

dictionary WebRequestCompletedDetails : WebRequestResponseWithIpEventDetails {};

dictionary WebRequestErrorOccurredDetails : WebRequestEventDetails {
  required DOMString error;
  required boolean fromCache;
  DOMString ip;
};

callback HandlerBehaviorChangedCallback = undefined ();

[Exposed=Window, IsolatedContext]
interface WebRequest {
  readonly attribute WebRequestEvent onBeforeRequest;
  readonly attribute WebRequestEvent onBeforeSendHeaders;
  readonly attribute WebRequestEvent onSendHeaders;
  readonly attribute WebRequestEvent onHeadersReceived;
  readonly attribute WebRequestEvent onAuthRequired;
  readonly attribute WebRequestEvent onBeforeRedirect;
  readonly attribute WebRequestEvent onResponseStarted;
  readonly attribute WebRequestEvent onCompleted;
  readonly attribute WebRequestEvent onErrorOccurred;

  undefined handlerBehaviorChanged(optional HandlerBehaviorChangedCallback callback);
};

The addListener(listener, filter, extraInfoSpec) method steps are:

1. Call removeListener with listener.

2. Let eventName be this’s eventName.

3. Let handlerConfig be a new WebRequest handler config with the following items:

   handler

   listener

   filter

   filter

4. Let specSet be a set containing the items in extraInfoSpec.

5. If eventName equals "beforeRequest", then:

   1. If specSet is not a subset of the set « "blocking", "requestBody", "extraHeaders" », then throw a TypeError.

   2. If specSet contains "blocking", then set handlerConfig’s blocking to true.

   3. If specSet contains "requestBody", then set handlerConfig’s requestsBody to true.

   4. If specSet contains "extraHeaders", then set handlerConfig’s requestsAllHeaders to true.

6. Otherwise, if eventName equals "beforeSendHeaders", then:

   1. If specSet is not a subset of the set « "blocking", "requestHeaders", "extraHeaders" », then throw a TypeError.

   2. If specSet contains "blocking", then set handlerConfig’s blocking to true.

   3. If specSet contains "requestHeaders", then set handlerConfig’s requestsHeaders to true.

   4. If specSet contains "extraHeaders", then set handlerConfig’s requestsAllHeaders to true.

7. Otherwise, if eventName equals "sendHeaders", then:

   1. If specSet is not a subset of the set « "requestHeaders", "extraHeaders" », then throw a TypeError.

   2. If specSet contains "requestHeaders", then set handlerConfig’s requestsHeaders to true.

   3. If specSet contains "extraHeaders", then set handlerConfig’s requestsAllHeaders to true.

8. Otherwise, if eventName equals "headersReceived", then:

   1. If specSet is not a subset of the set « "blocking", "responseHeaders", "extraHeaders" », then throw a TypeError.

   2. If specSet contains "blocking", then set handlerConfig’s blocking to true.

   3. If specSet contains "responseHeaders", then set handlerConfig’s requestsHeaders to true.

   4. If specSet contains "extraHeaders", then set handlerConfig’s requestsAllHeaders to true.

9. Otherwise, if eventName equals "authRequired", then:

   1. If specSet is not a subset of the set « "asyncBlocking", "blocking", "responseHeaders", "extraHeaders" », then throw a TypeError.

   2. If specSet contains "asyncBlocking", then set handlerConfig asyncBlocking to true.

   3. If specSet contains "blocking", then set handlerConfig’s blocking to true.

   4. If specSet contains "responseHeaders", then set handlerConfig’s requestsHeaders to true.

   5. If specSet contains "extraHeaders", then set handlerConfig’s requestsAllHeaders to true.

10. Otherwise, if eventName equals "beforeRedirect", then:

    1. If specSet is not a subset of the set « "responseHeaders", "extraHeaders" », then throw a TypeError.

    2. If specSet contains "responseHeaders", then set handlerConfig’s requestsHeaders to true.

    3. If specSet contains "extraHeaders", then set handlerConfig’s requestsAllHeaders to true.

11. Otherwise, if eventName equals "responseStarted", then:

    1. If specSet is not a subset of the set « "responseHeaders", "extraHeaders" », then throw a TypeError.

    2. If specSet contains "responseHeaders", then set handlerConfig’s requestsHeaders to true.

    3. If specSet contains "extraHeaders", then set handlerConfig’s requestsAllHeaders to true.

12. Otherwise, if eventName equals "completed", then:

    1. If specSet is not a subset of the set « "responseHeaders", "extraHeaders" », then throw a TypeError.

    2. If specSet contains "responseHeaders", then set handlerConfig’s requestsHeaders to true.

    3. If specSet contains "extraHeaders", then set handlerConfig’s requestsAllHeaders to true.

13. Otherwise, if eventName equals "errorOccurred", then:

    1. If specSet is not a subset of the set « "extraHeaders" », then throw a TypeError.

    2. If specSet contains "extraHeaders", then set handlerConfig’s requestsAllHeaders to true.

14. Otherwise, throw a TypeError.

15. Let handlerMap be the handler map of this’s webRequest.

16. Append handlerConfig to handlerMap[eventName].

The hasListener(listener) method steps are:

1. Let handlerMap be the handler map of this’s webRequest.

2. Let event name be this’s eventName.

3. For each handlerConfig in handlerMap[event name]:

   1. If handlerConfig’s handler equals listener, return true.

4. Return false.

The hasListeners() method steps are:

1. Let handlerMap be the handler map of this’s webRequest.

2. Let event name be this’s eventName.

3. If handlerMap[event name] is empty, return false, otherwise return true.

The removeListener(listener) method steps are:

1. Let handlerMap be the handler map of this’s webRequest.

2. Let event name be this’s eventName.

3. Let handlerConfigs be handlerMap[event name].

4. Remove all items from handlerConfigs whose handler equals listener.

The handlerBehaviorChanged(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 process beforeRequest events given a request request, run the following steps:

1. Let configs and blocking be the results of calling lookup registered WebRequest handler configs given "beforeRequest", and request.

2. Let combinedResults be an empty BlockingResponse.

3. Let pendingHandlerCount be configs’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 config in configs:

   1. Let details be the result of calling create a WebRequestEventDetails object given request.

   2. If config’s requestsBody is true and request’s body is not null, then:

      1. Let requestBody be an empty RequestBody.

      2. Let body be request’s body.

         TODO: serialize stream if present.

      3. Switch on body’s source:

         byte sequence

         Append an UploadData with bytes equal to the serialized body’s source to requestBody["raw"].

         Blob

         Append an UploadData with bytes equal to the serialized body’s source to requestBody["raw"].

         FormData

         1. Let formData be «[]».

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

            1. Switch on entry[1]:

            File

            Append an UploadData with file equal to entry[1]'s name to requestBody["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 details["formData"] to formData.

      4. Set details["requestBody"] to requestBody.

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

      1. Let result be the result of calling config’s handler given details.

         Note: Any exceptions thrown by the handler are intentionally ignored and will not affect the request.

      2. If all keys in result are contained in the set « "cancel", "redirect" », then:

         1. If result["cancel"] is true, then set combinedResults["cancel"] to true.

         2. If result["redirectUrl"] is a valid URL string and combinedResults["redirectUrl"] is undefined, then set combinedResults["redirectUrl"] to result["redirectUrl"].

      3. 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 combinedResults.

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

1. Let configs and blocking be the results of calling lookup registered WebRequest handler configs given "beforeSendHeaders", and request.

2. Let combinedResults be an empty BlockingResponse.

3. Let pendingHandlerCount be configs’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 config in configs:

   1. Let details be the result of calling create a WebRequestEventDetails object given request.

   2. If config’s requestsHeaders is true, then set details["requestHeaders"] to the result of calling convert a header list to an HttpHeader sequence given request’s header list, config’s requestsAllHeaders, and isRequest equal to true.

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

      1. Let result be the result of calling config’s handler given details.

         Note: Any exceptions thrown by the handler are intentionally ignored and will not affect the request.

      2. If all keys in result are contained in the set « "cancel", "requestHeaders" », then:

         1. If result["cancel"] is true, then set combinedResults["cancel"] to true.

         2. If result["requestHeaders"] is a list whose size > 0, then:

            1. Set combinedResults["requestHeaders"] to [] if it is not defined.

            2. Append the contents of result["requestHeaders"] to combinedResults["requestHeaders"].

      3. 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 combinedResults.

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

1. Let configs be the result of calling lookup registered WebRequest handler configs given "sendHeaders", and request.

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

3. For each config in configs:

   1. Let details be the result of calling create a WebRequestEventDetails object given request.

   2. If config’s requestsHeaders is true, then set details["requestHeaders"] to the result of calling convert a header list to an HttpHeader sequence given request’s header list, config’s requestsAllHeaders, and isRequest equal to true.

   3. Queue a global task on the DOM manipulation task source of embedderGlobal that will call config’s handler given details.

To process headersReceived events given a request request and a response response, run the following steps:

1. Let configs and blocking be the results of calling lookup registered WebRequest handler configs given "headersReceived", and request.

2. Let combinedResults be an empty BlockingResponse.

3. Let pendingHandlerCount be configs’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 config in configs:

   1. Let details be the result of calling create a WebRequestResponseEventDetails object given request and response.

   2. If config’s requestsHeaders is true, then set details["responseHeaders"] to the result of calling convert a header list to an HttpHeader sequence given response’s header list, config’s requestsAllHeaders, and isRequest equal to false.

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

      1. Let result be the result of calling config’s handler given details.

         Note: Any exceptions thrown by the handler are intentionally ignored and will not affect the request.

      2. If all keys in result are contained in the set « "cancel", "redirectUrl", "responseHeaders" », then:

         1. If result["cancel"] is true, then set combinedResults["cancel"] to true.

         2. If result["redirectUrl"] is a valid URL string and combinedResults["redirectUrl"] is undefined, then set combinedResults["redirectUrl"] to result["redirectUrl"].

         3. If result["responseHeaders"] is a list whose size > 0, then:

            1. Set combinedResults["responseHeaders"] to [] if it is not defined.

            2. Append the contents of result["responseHeaders"] to combinedResults["responseHeaders"].

      3. 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 combinedResults.

To process authRequired events given a request request and a response response, run the following steps:

1. Let configs and blocking be the results of calling lookup registered WebRequest handler configs given "authRequired", and request.

2. Let challenger be an AuthChallenger with host and port equal to the host and port of response’s URL.

3. If response’s status is 401, then:

   1. Let isProxy be false.

   2. Let scheme be the scheme from response’s WWW-Authenticate header, parsed as defined by the [HTML] specification, or null if the header is missing or invalid.

   3. Let realm be the realm from response’s WWW-Authenticate header, parsed as defined by the [HTML] specification.

4. Otherwise:

   1. Let isProxy be true.

   2. Let scheme be the scheme from response’s Proxy-Authenticate header, parsed as defined by the [HTML] specification, or null if the header is missing or invalid.

   3. Let realm be the realm from response’s Proxy-Authenticate header, parsed as defined by the [HTML] specification.

5. If scheme is null, then return null.

6. Let combinedResults be an empty BlockingResponse.

7. Let pendingHandlerCount be configs’s size.

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

9. For each config in configs:

   1. Let details be the result of calling create a WebRequestResponseEventDetails object given request and response.

   2. If config’s requestsHeaders is true, then set details["responseHeaders"] to the result of calling convert a header list to an HttpHeader sequence given response’s header list, config’s requestsAllHeaders, and isRequest equal to false.

   3. Set details["challenger"], details["isProxy"], details["scheme"], and details["realm"] fields equal to challenger, isProxy, scheme, and realm respectively.

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

      1. Let result be null.

      2. If config’s asyncBlocking flag is true, then:

         1. Let callback be a function that takes a BlockingResponse blockingResponse argument and when executed will set result to blockingResponse.

         2. Call config’s handler given details and callback.

         3. Wait in parallel for callback to be invoked, and then continue executing these steps.

      3. Otherwise:

         1. Set result to the result of calling config’s handler given details.

            Note: Any exceptions thrown by the handler are intentionally ignored and will not affect the request.

      4. If all keys in result are contained in the set « "cancel", "authCredentials" » and result["authCredentials"] is either undefined or a dictionary containing two keys equal to "username" and "password", then:

         1. If result["cancel"] is true, then set combinedResults["cancel"] to true.

         2. If result["authCredentials"] is defined and combinedResults["authCredentials"] is undefined, then set combinedResults["authCredentials"] to result["authCredentials"].

      5. Decrement pendingHandlerCount.

10. 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.

11. Return combinedResults.

To process beforeRedirect events given a request request and a response response, run the following steps:

1. Let configs be the result of calling lookup registered WebRequest handler configs given "beforeRedirect", and request.

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

3. For each config in configs:

   1. Let details be the result of calling create a WebRequestResponseWithIpEventDetails object given request and response.

   2. If config’s requestsHeaders is true, then set details["responseHeaders"] to the result of calling convert a header list to an HttpHeader sequence given response’s header list, config’s requestsAllHeaders, and isRequest equal to false.

   3. Let internalResponse be response, if response is not a filtered response; otherwise response’s internal response.

   4. Set details["redirectUrl"] to internalResponse’s location URL given request’s current URL’s fragment.

   5. Queue a global task on the DOM manipulation task source of embedderGlobal that will call config’s handler given details.