受控框架 API

当 controlledframe 元素 element 被插入到一个文档中，且该文档的 浏览上下文为非 null 时，运行以下步骤：

1. 如果 element 的 src 不为空，则：

   1. 给定 element，初始化 controlledframe。

当 controlledframe 元素 element 被从文档中移除时， 运行以下步骤：

1. 给定 element 的 嵌入的 navigable，销毁一个顶级 traversable。

2. 将 element 的嵌入的 navigable设置为 null。

要初始化一个 controlledframe 元素 element，运行 以下步骤：

1. 断言 element 的嵌入的 navigable为 null。

2. 令 group 为一个新的浏览上下文组。

3. 令 document 为给定 element 的节点文档、element 和 group，创建新的浏览上下文和 文档的第二个返回值。

4. 令 documentState 为一个新的文档状态，其文档 为 document。

5. 令 traversable 为一个新的traversable navigable。

6. 给定 documentState，初始化 navigable traversable。

7. 将 traversable 的 controlledFrameEmbedderParent 设置为 element。

8. 将 element 的嵌入的 navigable设置为 traversable。

9. 令 initialHistoryEntry 为 traversable 的活动会话历史条目。

10. 将 initialHistoryEntry 的步数设置为 0。

11. 将 initialHistoryEntry 追加到 traversable 的会话历史条目。

    这些步骤 是在新的 navigable 中初始化 History.length 所必需的。这是 HTML 标准中的一个现有 议题。

12. 将 element 的 contentWindow 设置为 document 的 WindowProxy。

13. 给定 element 和 element 的 src， 导航 controlledframe。

要导航一个 controlledframe 元素 element，给定一个 USVString urlString，运行以下步骤：

1. 如果 urlString 不是绝对 URL 字符串，则返回。

2. 令 url 为给定 urlString 和 element 的节点文档，解析 URL的结果。

3. 令 historyHandling 为 "auto"。

4. 如果 element 的嵌入的 navigable的活动文档未 完全加载，则将 historyHandling 设置为 "replace"。

5. 使用 element 的 节点文档，并以 historyHandling 作为 NavigationHistoryBehavior， 将 element 的嵌入的 navigable导航到 url。

HTMLControlledFrameElement() 构造器步骤为：

1. 将 this 的request设置为一个新的 WebRequest。

2. 将 this 的contextMenus设置为一个新的 ContextMenus。

要解决嵌入者 promise，给定一个 controlledframe controlledframe、一个 promise promise 以及一个可选的 value， 运行以下步骤：

1. 在 controlledframe 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以使用 value 解决 promise。

   注： controlledframe 的相关全局对象是 嵌入者的 Window 对象。

要拒绝嵌入者 promise，给定一个 controlledframe controlledframe、一个 promise promise 以及一个可选的 value， 运行以下步骤：

1. 在 controlledframe 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以使用 value 拒绝 promise。

   注： controlledframe 的相关全局对象是 嵌入者的 Window 对象。

如果以下步骤返回 true，则一个 URL url 匹配 URLPattern pattern：

1. 令 result 为给定 pattern 和 url，匹配的结果。

2. 如果 result 为 null，则返回 false。

3. 返回 true。

partition IDL 属性设置器步骤为：

1. 如果 this 的嵌入的 navigable不是 null，则：

   1. 抛出一个 "NotSupportedError" DOMException。

2. 将 this 的 partition 设置为给定值。

src IDL 属性设置器步骤为：

1. 如果 this 不在文档树中，则返回。

2. 如果 this 的嵌入的 navigable为 null，则：

   1. 给定 this，初始化 controlledframe。

3. 否则：

   1. 给定 this 和给定值，导航 controlledframe。

要增量遍历嵌入的 navigable 的历史， 给定一个 controlledframe controlledframe 和一个整数 delta，运行 以下步骤：

1. 令 resultPromise 为一个新的 promise。

2. 返回 resultPromise，并并行运行剩余步骤。

3. 令 embeddedNavigable 为 controlledframe 的嵌入的 navigable。

4. 如果 embeddedNavigable 为 null，则给定 controlledframe、resultPromise 和 false，解决嵌入者 promise，并中止这些 步骤。

5. 如果 embeddedNavigable 的活动文档不是完全活动的， 则给定 controlledframe、resultPromise 和 false，解决嵌入者 promise，并中止这些步骤。

6. 向 embeddedNavigable 追加以下会话历史 遍历步骤：

   1. 令 allSteps 为对 embeddedNavigable 获取所有已使用历史步骤 的结果。

   2. 令 currentStepIndex 为 embeddedNavigable 的 当前会话历史步骤在 allSteps 中的索引。

   3. 令 targetStepIndex 为 currentStepIndex + delta。

   4. 如果 allSteps[targetStepIndex] 不存在，则 给定 controlledframe、resultPromise 和 false，解决嵌入者 promise，并中止这些步骤。

   5. 令 result 为给定 "none" 的用户导航参与，将 遍历历史步骤 allSteps[targetStepIndex] 应用到 embeddedNavigable 的结果。

   6. 如果 result 不等于 "applied"，则给定 controlledframe、resultPromise 和 false， 解决嵌入者 promise。

   7. 否则，给定 controlledframe、 resultPromise 和 true，解决嵌入者 promise。

canGoBack() 方法步骤为：

1. 令 result 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 令 embeddedNavigable 为 controlledframe 的嵌入的 navigable。

4. 如果 embeddedNavigable 为 null，则用 false 解决 result 并返回 result。

5. 在 embeddedNavigable 的节点文档的相关全局对象的导航和遍历任务源上 排队一个全局任务，它将运行以下步骤：

   1. 如果 embeddedNavigable 的 当前会话历史步骤 > 0， 则令 canGoBack 为 true，否则为 false。

   2. 给定 controlledframe、result 和 canGoBack，解决嵌入者 promise。

6. 返回 result。

canGoForward() 方法步骤为：

1. 令 result 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 令 embeddedNavigable 为 controlledframe 的嵌入的 navigable。

4. 如果 embeddedNavigable 为 null，则用 false 解决 result 并返回 result。

5. 在 embeddedNavigable 的节点文档的相关全局对象的 导航和遍历任务源上 排队一个全局任务，它将运行以下步骤：

   1. 令 step 为 embeddedNavigable 的当前会话历史步骤。

   2. 令 steps 为给定 embeddedNavigable，获取所有已使用历史步骤 的结果。

   3. 如果 step + 1 < steps 的大小， 则令 canGoForward 为 true，否则为 false。

   4. 给定 controlledframe、result 和 canGoForward，解决嵌入者 promise。

6. 返回 result。

back() 方法步骤为：

1. 返回给定 this 和 -1，增量遍历嵌入的 navigable 的历史的结果。

forward() 方法步骤 为：

1. 返回给定 this 和 1，增量遍历嵌入的 navigable 的历史的结果。

go(relativeIndex) 方法步骤为：

1. 返回给定 this 和 relativeIndex，增量遍历嵌入的 navigable 的历史的结果。

reload() 步骤为：

1. 令 embeddedNavigable 为 this 的嵌入的 navigable。

2. 如果 embeddedNavigable 为 null，则返回。

3. 在 embeddedNavigable 的节点文档的相关全局对象的 导航和遍历任务源上 排队一个全局任务，它将给定 "none" 的 用户导航参与，重新加载 embeddedNavigable。

stop() 步骤为：

1. 令 embeddedNavigable 为 this 的嵌入的 navigable。

2. 如果 embeddedNavigable 为 null，则返回。

3. 在 embeddedNavigable 的节点文档的相关全局对象的 导航和遍历任务源上 排队一个全局任务，它将停止加载 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;
};

要获取一个 注入项，给定一个 controlledframe controlledframe、一个 USVString urlString、一个 布尔值 isCss、一个 long index，以及一个接受 long、 一个 boolean 和一个 DOMString 的算法 completionSteps，运行以下步骤：

注：这里不能使用获取经典脚本，因为获取 需要使用 controlledframe 的相关设置对象，但 经典脚本是使用嵌入的 navigable的 活动文档的相关设置对象执行的。

1. 如果 urlString 不是有效 URL 字符串，则：

   1. 给定 0、false 和 ""，运行 completionSteps。

   2. 返回。

2. 令 request 为一个具有以下字段的新请求：

   URL

   给定 urlString 和 controlledframe 的节点文档，解析 URL的结果。

   method

   "GET"

   destination

   如果 isCss 为 true，则为 "style"，否则为 "script"

   client

   controlledframe 的相关设置对象

   mode

   "cors"

3. 获取 request，并将 processResponseConsumeBody 设置为以下步骤，给定一个 响应 response 和一个 null、failure 或 字节序列 contents：

   1. 如果 response 的状态不是 200，或 contents 为 null 或 failure，则给定 0、false 和 "" 运行 completionSteps

   2. 否则，给定 index、true 和 contents 运行 completionSteps。

要验证并解析 ContentScriptDetails， 给定一个 controlledframe controlledframe 和一个 ContentScriptDetails details，运行以下步骤：

1. 令 result 为一个新的 promise。

2. 如果 details["js"] 和 details["css"] 均已定义，或均 未定义，则用 TypeError 拒绝 result，并返回它。

3. 如果 details["urlPatterns"] 为空， 则用 TypeError 拒绝 result，并返回它。

4. 令 isCss 为一个布尔值，如果 details["css"] 已定义，则等于 true，否则等于 false。

5. 如果 isCss 为 true 且 details["runAt"] 不等于 "document-start"， 则用 TypeError 拒绝 result，并返回它。

6. 如果 isCss 为 true，则令 injectionItems 为 details["css"]， 否则为 details["js"]。

7. 如果 injectionItems["code"] 和 injectionItems["files"] 均已定义，或均 未定义，则用 TypeError 拒绝 result，并返回它。

8. 返回 result，并并行运行剩余步骤。

9. 令 config 为一个新的内容脚本配置，具有以下值：

   pendingFetchCount

   0

   urlPatterns

   «»

   excludeURLPatterns

   «»

   allFrames

   如果已定义，则为 details["allFrames"]， 否则为 false

   matchAboutBlank

   如果已定义，则为 details["matchAboutBlank"]， 否则为 false

   runAt

   如果已定义，则为 details["runAt"]， 否则为 document-idle

10. 对于 details["urlPatterns"] 中的每个 urlPattern：

    1. 如果 urlPattern 是一个 URLPattern， 则将 urlPattern 追加到 config 的urlPatterns。

    2. 否则，给定 urlPattern，将一个新的 URLPattern 追加到 config 的urlPatterns。

11. 如果 details["excludeURLPatterns"] 已定义， 则：

    1. 对于 details["excludeURLPatterns"] 中的每个 urlPattern：

       1. 如果 urlPattern 是一个 URLPattern， 则将 urlPattern 追加到 config 的 excludeURLPatterns。

       2. 否则，给定 urlPattern，将一个新的 URLPattern 追加到 config 的 excludeURLPatterns。

12. 令 completionSteps 为以下算法，其接受一个 long index、一个 布尔值 success 和一个 DOMString source：

    1. 如果 success 为 false，则给定 controlledframe、result 和 TypeError， 拒绝嵌入者 promise，并中止 这些步骤。

    2. 如果 isCss，则：

       1. 将 config 的 css[index] 设置为 source。

    3. 否则：

       1. 将 config 的 js[index] 设置为 source。

    4. 递减 config 的 pendingFetchCount。

    5. 如果 config 的 pendingFetchCount 大于 0，则返回。

    6. 将 controlledframe 的内容脚本 映射[details[name]] 设置为 config。

    7. 给定 controlledframe 和 result，解决嵌入者 promise。

13. 如果 injectionItems["code"] 已定义，则：

    1. 给定 0、true 和 injectionItems ["code"]，运行 completionSteps。

14. 否则：

    1. 如果 injectionItems["files"] 为空，则 给定 controlledframe、result 和 TypeError，拒绝嵌入者 promise， 并中止这些步骤。

    2. 对于 injectionItems ["files"] 的每个 urlString：

       1. 给定 controlledframe、 urlString、isCss、config 的 pendingFetchCount 和 completionSteps，运行获取注入项。

       2. 递增 config 的 pendingFetchCount。

要确定一个内容脚本配置是否适用于某个文档， 给定一个内容 脚本配置 config、一个 URL url 和一个 布尔值 isTopLevel，运行以下步骤：

1. 如果 isTopLevel 为 false，且 config 的 allFrames 为 false，则 返回 false。

2. 如果 url 匹配 about:blank，且 config 的 matchAboutBlank 为 false，则返回 false。

3. 令 urlString 为 序列化 url 的结果。

4. 令 match 为 false。

5. 对于 config 的 urlPatterns 的每个 pattern：

   1. 如果 urlString 匹配 URLPattern pattern，则将 match 设置为 true。

6. 对于 config 的 excludeURLPatterns 的每个 pattern：

   1. 如果 urlString 匹配 URLPattern pattern，则将 match 设置为 false。

7. 返回 match。

要将内容脚本注入到文档中，给定一个 Document document，以及一个 RunAt currentPhase，运行以下步骤：

1. 令 embeddedNavigable 为 document 的节点 navigable的 traversable navigable。

2. 如果 embeddedNavigable 为 null，或其 controlledFrameEmbedderParent 为 null，则 返回。

3. 令 controlledframe 为 embeddedNavigable 的 controlledFrameEmbedderParent。

4. 令 url 为 document 的 URL。

5. 如果 document 的节点 navigable的 parent 为 null，则令 isTopLevel 为 true，否则为 false。

6. 对于 controlledframe 的 内容脚本映射中的每个 config：

   1. 如果给定 config、url 和 isTopLevel，确定内容脚本配置是否适用于文档的结果等于 false，则继续。

   2. 如果 currentPhase 等于 document-start 且 config 的 css 不是空， 则：

      1. 对于 config 的 css 的每个 styleSource，给定 document 和 styleSource，运行将样式表注入到 文档中。

   3. 否则，如果 currentPhase 等于 config 的 runAt，则：

      1. 对于 config 的 js 的每个 scriptSource，给定 document、scriptSource 和一个 空 算法，运行将脚本注入到 文档中。

要将样式表注入到文档中，给定一个 Document document 和一个 DOMString styleSource，运行以下步骤：

1. 令 styleSheet 为一个新的 CSS 样式表对象。

2. 给定 styleSheet 和 styleSource，同步替换 CSSStyleSheet 的规则。

3. 在 document 的全局对象的 DOM 操作任务源上排队一个全局任务，以给定 document 和 styleSheet，添加 CSS 样式表。

要将 脚本注入到文档中，给定一个 Document document、 一个 DOMString scriptSource，以及一个接受 完成记录的算法 completionSteps，运行以下步骤：

注：执行 scriptSource 时会故意不设置 document.currentScript。

1. 令 script 为给定 scriptSource、document 的相关设置对象、document 的 URL，以及默认脚本获取选项，创建经典脚本的结果。

2. 在 document 的全局对象的 DOM 操作任务源上排队一个全局任务，该任务将运行以下步骤：

   1. 令 completionRecord 为给定 script，运行经典脚本 的结果。

   2. 令 controlledframe 为 document 的节点 navigable的 traversable navigable的controlledFrameEmbedderParent。

   3. 在 controlledframe 的相关全局对象的 DOM 操作任务源上排队一个全局任务，该任务将以 completionRecord 运行 completionSteps。

addContentScripts(contentScriptList) 方法步骤为：

1. 如果 contentScriptList 为空，则返回 一个以 TypeError 拒绝的新 promise。

2. 令 promises 为空列表。

3. 对于 contentScriptList 中的每个 contentScript：

   1. 令 promise 为给定 contentScript，调用验证并解析 ContentScriptDetails的结果。

   2. 将 promise 追加到 promises。

4. 返回给定 promises，获取一个等待所有 promise 的 promise 的结果。

removeContentScripts(scriptNameList) 方法步骤为：

1. 令 result 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 result，并并行运行剩余步骤。

4. 如果 scriptNameList 为 undefined，则：

   1. 清空 controlledframe 的内容脚本映射。

5. 否则，对于 scriptNameList 的每个 name：

   1. 移除 controlledframe 的内容脚本 映射[name]。

6. 给定 controlledframe 和 result，解决嵌入者 promise。

executeScript(details) 方法步骤为：

1. 令 result 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 result，并并行运行剩余步骤。

4. 如果 controlledframe 的嵌入的 navigable为 null，则给定 controlledframe、result 和一个 TypeError， 拒绝嵌入者 promise，并中止这些步骤。

5. 如果 details["code"] 和 details"[file"] 两者都已定义或两者都 未定义，则给定 controlledframe、 result 和一个 TypeError，拒绝嵌入者 promise， 并中止这些步骤。

6. 令 executionSteps 为以下算法，它接受一个 long 和 一个 DOMString 或 布尔值 scriptString：

   1. 如果 scriptString 不是 DOMString， 则给定 controlledframe、result 和一个 TypeError， 拒绝嵌入者 promise， 并中止这些步骤。

   2. 令 document 为 controlledframe 的嵌入的 navigable的 活动文档。

   3. 给定 document、scriptString 以及以下接受完成记录 completionRecord 的算法，将脚本注入到文档中：

      1. 如果 completionRecord 是正常 完成，则：

         1. 给定 controlledframe、 result 和 completionRecord.[[Value]]，解决嵌入者 promise。

      2. 否则：

         1. 给定 controlledframe、 result 和 completionRecord.[[Value]]，拒绝嵌入者 promise。

7. 如果 details["code"] 已定义，则给定 0 和 details["code"]，运行 executionSteps。

8. 否则，给定 controlledframe、 details["file"]、 false、0 和 executionSteps，获取一个注入项。

insertCSS(details) 方法步骤为：

1. 令 result 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 result，并并行运行剩余步骤。

4. 如果 controlledframe 的嵌入的 navigable为 null，则 给定 controlledframe、result 和一个 TypeError， 拒绝嵌入者 promise， 并中止这些步骤。

5. 如果 details["code"] 和 details["file"] 两者都已定义或两者都 未定义，则给定 controlledframe、 result 和一个 TypeError，拒绝嵌入者 promise， 并中止这些步骤。

6. 令 executionSteps 为以下算法，它接受一个 long、 一个 布尔值 success 和一个 DOMString styleString：

   1. 如果 success 为 false，则给定 controlledframe、result 和一个 TypeError， 拒绝 嵌入者 promise，并中止这些 步骤。

   2. 令 document 为 controlledframe 的嵌入的 navigable的 活动文档。

   3. 给定 document 和 styleString，将样式表注入到 文档中。

   4. 给定 controlledframe 和 result，解决嵌入者 promise。

7. 如果 details["code"] 已定义，则给定 0、true 和 details["code"]，运行 executionSteps。

8. 否则，给定 controlledframe、 details["file"]、 false、0 和 executionSteps，获取一个注入项。

dictionary ClearDataOptions {
  long since;
};

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

要清空一个存储瓶，给定一个存储桶 bucket、 一个存储标识符 identifier，以及一个 long since，运行 以下步骤：

注：如果可能，用户代理应仅 移除在 since 之后最后使用的数据，其中 since 表示自 纪元以来的毫秒时间戳。并非所有用户代理都会跟踪所有 浏览数据的写入或访问时间。实现应尽其所能尊重 since， 但该 API 不保证其可用性。

1. 令 bottle 为 bucket[identifier]。

2. 清空 bottle 的映射。

3. 将 bottle 的代理映射引用集合设置为一个新的集合。

clearData(options, types) 方法步骤为：

1. 令 resultPromise 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 resultPromise，并并行运行剩余步骤。

4. 令 clearSince 为 0。

5. 如果 options["since"] 已定义，则将 clearSince 设置为 options|["since"]。

6. 令 embeddingOrigin 为 controlledframe 的相关设置对象的顶级源。

7. 令 partition 为 controlledframe 的 partition。

8. 对于用户代理的 存储棚中的每个 storageKey → shelf：

   1. 如果 storageKey 的嵌入源不等于 embeddingOrigin，或 storageKey 的分区不 等于 partition，则继续。

   2. 令 bucket 为 shelf["default"]。

   3. 如果 types["fileSystems"] 为 true：

      1. 给定 bucket、"fileSystem" 和 clearSince，清空存储瓶。

   4. 如果 types["indexedDB"] 为 true：

      1. 给定 bucket、"indexedDB" 和 clearSince，清空存储瓶。

   5. 如果 types["localStorage"] 为 true：

      1. 给定 bucket、"localStorage" 和 clearSince，清空存储瓶。

9. 如果 types["cookies"]、 types["persistentCookies"]， 或 types["sessionCookies"] 为 true，则：

   [COOKIES] 规范不支持通过类似存储键的机制 对 cookie 进行分区。以下步骤 会清除所有 cookie，但其意图是仅删除 由此 Controlled Frame 当前 partition 中的 Controlled Frame 内容所 创建的 cookie。

   1. 对于用户代理的 cookie 存储中的每个 cookie：

      1. 如果 cookie 的 persistent-flag 已设置，则：

         1. 如果 types["cookies"] 和 types["persistentCookies"] 为 false， 则继续。

      2. 否则：

         1. 如果 types["cookies"] 和 types["sessionCookies"] 为 false， 则继续。

      3. 如果 cookie 的 last-access-time 表示为自 纪元以来的毫秒数小于 clearSince，则继续。

      4. 从用户代理的 cookie 存储中移除 cookie。

10. 如果 types["cache"] 为 true，则：

    1. 对于 用户代理管理的每个 storageKey → cache：[HTTP-CACHING]

       1. 如果 storageKey 的嵌入源不等于 embeddingOrigin，或 storageKey 的分区不等于 partition， 则继续。

       2. 清空 cache。

11. 给定 controlledframe 和 resultPromise，解决嵌入者 promise。

getAudioState() 方法步骤为：

1. 令 resultPromise 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 resultPromise，并并行运行剩余步骤。

4. 如果 controlledframe 的嵌入的 navigable为 null，则给定 controlledframe、resultPromise 和一个 TypeError， 拒绝嵌入者 promise，并中止这些步骤。

5. 如果 controlledframe 的嵌入的 navigable内的任何内容（包括嵌套框架中的内容）当前正在 播放 音频，则令 playingAudio 为 true，否则为 false。

6. 给定 controlledframe、resultPromise 和 playingAudio，解决嵌入者 promise。

isAudioMuted() 方法步骤为：

1. 令 resultPromise 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 resultPromise，并并行运行剩余步骤。

4. 如果 controlledframe 的嵌入的 navigable为 null，则给定 controlledframe、resultPromise 和一个 TypeError， 拒绝嵌入者 promise，并中止这些步骤。

5. 给定 controlledframe、resultPromise 以及 controlledframe 的嵌入的 navigable的 muted 标志，解决嵌入者 promise。

setAudioMuted(mute) 方法步骤为：

1. 如果 this 的嵌入的 navigable为 null，则抛出一个 TypeError。

2. 将 this 的嵌入的 navigable的 muted 标志设置为 mute。

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

要获取 按源缩放级别，给定 HTMLControlledFrameElement e，运行以下步骤：

1. 令 result 为初始设置为 1.0f 的浮点数。

2. 令 key 为给定与 e 的嵌入的 navigable的活动文档的当前设置对象相关联的环境，获取 Controlled Frame 存储键的结果。

3. 如果 Controlled Frame 缩放映射[key] 存在，则将 result 设置为给定键 key，从 Controlled Frame 缩放映射获取 值的结果。

4. 返回 result。

要设置 按源缩放级别，给定 HTMLControlledFrameElement e 和一个浮点数 zoomLevel，运行以下步骤：

1. 令 key 为给定与 e 的嵌入的 navigable的活动文档的当前设置对象相关联的环境，获取 Controlled Frame 存储键的结果。

2. 给定键 key 和值 zoomLevel，设置 值到 Controlled Frame 缩放映射。

要确定给定 HTMLControlledFrameElement e 时，当前文档是否具有按源缩放 级别，运行以下步骤：

1. 令 key 为给定与 e 的嵌入的 navigable的活动文档的当前设置对象相关联的环境，获取 Controlled Frame 存储键的结果。

2. 如果 Controlled Frame 缩放映射[key] 存在，返回 true。

3. 返回 false。

getZoomMode() 方法 步骤为：

1. 令 p 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 p，并并行运行剩余步骤。

4. 给定 controlledframe、p 和 controlledframe 的zoomMode，解决嵌入者 promise。

setZoomMode(zoomMode) 方法步骤为：

1. 令 p 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 p，并并行运行剩余步骤。

4. 令 currentZoomMode 为给定 controlledframe，getZoomMode 的结果。

5. 如果 currentZoomMode 等于 zoomMode，则给定 controlledframe 和 p，解决嵌入者 promise。

6. 将 controlledframe 的 zoomMode 设置为 zoomMode。

7. 如果 zoomMode 为 per-origin：

   1. 如果给定 controlledframe，当前文档具有 按源缩放级别为 true：

      1. 令 oldZoomFactor 为 controlledframe 的 currentZoom。

      2. 将 controlledframe 的 currentZoom 设置为给定 controlledframe，获取按源缩放级别 的结果。

      3. 如果 oldZoomFactor 不等于 controlledframe 的 currentZoom：

         1. 给定 controlledframe 的 currentZoom，将缩放级别应用到 controlledframe 的嵌入文档。

         2. 使用 controlledframe、oldZoomFactor 和 controlledframe 的 currentZoom，触发 "zoomchange" 事件。

8. 如果 zoomMode 为 disabled：

   1. 令 oldZoomFactor 为 controlledframe 的 currentZoom。

   2. 将 controlledframe 的 currentZoom 设置为 1.0f。

   3. 如果 oldZoomFactor 不等于 controlledframe 的 currentZoom：

      1. 给定 controlledframe 的 currentZoom，将缩放级别应用到 controlledframe 的嵌入文档。

      2. 使用 controlledframe、oldZoomFactor 和 controlledframe 的 currentZoom，触发 "zoomchange" 事件。

9. 给定 controlledframe 和 p，解决嵌入者 promise。

getZoom() 方法步骤 为：

1. 令 p 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 p，并并行运行剩余步骤。

4. 令 embeddedNavigable 为 controlledframe 的嵌入的 navigable。

5. 如果 embeddedNavigable 为 null，则给定 controlledframe、p 和一个 TypeError， 拒绝嵌入者 promise，并中止这些步骤。

6. 给定 controlledframe、p 和 controlledframe 的 currentZoom，解决嵌入者 promise。

setZoom(zoomFactor) 方法 步骤为：

1. 令 p 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 p，并并行运行剩余步骤。

4. 令 embeddedNavigable 为 controlledframe 的嵌入的 navigable。

5. 如果 embeddedNavigable 为 null，则给定 controlledframe、p 和一个 TypeError， 拒绝嵌入者 promise，并中止这些步骤。

6. 如果 controlledframe 的 ZoomMode 为 disabled：

   1. 给定 controlledframe、p 和一个 TypeError， 拒绝嵌入者 promise， 并中止这些步骤。

7. 如果 controlledframe 的 ZoomMode 为 per-origin：

   1. 令 oldZoomFactor 为 controlledframe 的 currentZoom。

   2. 给定 controlledframe 和 zoomFactor，设置按源缩放级别。

   3. 对于用户代理的 浏览上下文组集合中的每个 浏览上下文组 group：

      1. 对于 group 中的每个 顶级浏览上下文 browsingContext：

         1. 令 embeddedDocument 为 browsingContext 的 活动文档。

         2. 令 embedder 为 embeddedDocument 的节点 navigable的 controlledFrameEmbedderParent。

         3. 如果 embedder 为 null，则继续。

         4. 如果以下所有条件均为 true，则令 match 为 true：

            • embedder 的 ZoomMode 为 per-origin

            • embedder 的 partition 等于 controlledframe 的 partition

            • embeddedDocument 的源等于 controlledframe 的嵌入的 navigable的 活动文档的源

            • embedder 的 currentZoom 不等于 zoomFactor

         5. 如果 match 为 true，则：

            1. 将 embedder 的 currentZoom 设置为 zoomFactor。

            2. 给定 zoomFactor，将缩放级别应用到 embeddedDocument。

            3. 使用 embedder、 oldZoomFactor 和 zoomFactor，触发 "zoomchange" 事件。

8. 如果 controlledframe 的 ZoomMode 为 per-view：

   1. 令 oldZoomFactor 为 controlledframe 的 currentZoom。

   2. 将 controlledframe 的 currentZoom 设置为 zoomFactor。

   3. 如果 oldZoomFactor 不等于 controlledframe 的 currentZoom：

      1. 给定 controlledframe 的 currentZoom，将缩放级别应用到 controlledframe 的嵌入文档。

      2. 使用 controlledframe、 oldZoomFactor、controlledframe 的currentZoom，触发 "zoomchange" 事件。

9. 给定 controlledframe 和 p，解决嵌入者 promise。

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

captureVisibleRegion(options) 方法步骤为：

1. 令 resultPromise 为一个新的 promise。

2. 令 controlledframe 为 this。

3. 返回 resultPromise，并并行运行剩余步骤。

4. 如果 controlledframe 的嵌入的 navigable为 null，则给定 controlledframe、resultPromise 和一个 TypeError， 拒绝嵌入者 promise，并中止这些步骤。

5. 令 optionsFormat 默认为 "JPEG"。

6. 令 optionsQuality 默认为 100。

7. 如果 options 有字段 "format"：

   1. 令 optionsFormat 为 options["format"]。

8. 如果 optionsFormat 是无法识别的格式，则给定 controlledframe、 resultPromise 和一个 TypeError， 拒绝嵌入者 promise，并中止这些步骤。

9. 如果 options 有字段 "quality"：

   1. 令 optionsQuality 为 options["quality"]。

10. 如果 optionsQuality 不是整数，或不在 0 到 100（含）之间， 则给定 controlledframe、 resultPromise 和一个 TypeError， 拒绝嵌入者 promise，并中止这些步骤。

11. 令 imageData 为一张显示嵌入内容可见区域的图像，该图像以 optionsFormat 编码，质量为 optionsQuality。

    注：受支持图像格式的集合由实现定义， 但建议至少支持 "JPEG" 和 "PNG"。

12. 给定 controlledframe、resultPromise 和一个包含 imageData 的 data: URL，解决嵌入者 promise。

print() 方法步骤为：

1. 如果 this 的嵌入的 navigable为 null，则抛出一个 TypeError。

2. 为嵌入内容启动浏览器打印页面功能。

[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;
};

要触发 ConsoleMessageEvent e，给定 controlledframe 元素 target、一个 long logLevel 和一个 DOMString message， 运行以下步骤：

1. 令 consoleMessage 为一个新的 ConsoleMessage 对象。

2. 设置 consoleMessage 的以下字段：

   level

   logLevel。

   message

   message。

3. 将 e 的 consoleMessage 设置为 consoleMessage。

4. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 target 上分派 e。

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;
};

要触发 DialogEvent e，给定 controlledframe 元素 target、简单对话框类型 dialogType，以及 消息 message，运行以下步骤：

1. 断言 e["dialogMessage"]["dialog"]["accept"] 等于 false。

2. 令 dialogMessage 为一个新的 DialogMessage 对象。

3. 令 dialog 为一个新的 DialogController 对象。

4. 设置 dialogMessage 的以下字段：

   messageType

   dialogType。

   messageText

   message。

   dialog

   dialog。

5. 将 e 的 dialogMessage 设置为 dialogMessage。

6. 令 complete 为 false。

7. 在 target 的相关全局对象的DOM 操作任务源上排队一个全局任务，以运行以下 步骤：

   1. 在 target 上分派 e。

   2. 将 complete 设置为 true。

8. 同步等待 complete 为 true。

   注： 此处阻塞是有意为之，因为 由 "dialog" 事件表示的 alert、confirm 和 prompt 对话框会阻塞主线程，并且我们在这里调用的事件 处理程序会影响返回值。

9. 返回 e["dialogMessage"]["dialog"]["accept"] 以及 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;
};

要触发 NewWindowEvent e， 给定 controlledframe 元素 controlledFrame、USVString url、 DOMString target、navigable targetNavigable 和 WindowOpenDisposition windowOpenDisposition，运行以下步骤：

1. 令 controller 为一个新的 NewWindowController 对象。

2. 将 controller 的目标 navigable设置为 targetNavigable。

3. 令 newWindow 为一个新的 NewWindow 对象。

4. 设置 newWindow 的以下字段：

   window

   controller

   targetUrl

   url

   name

   target。

   windowOpenDisposition

   windowOpenDisposition

5. 将 e 的 newWindow 设置为 newWindow。

6. 在 controlledFrame 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 controlledFrame 上分派 e。

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;
};

要触发 PermissionRequestEvent e，给定一个文档 embeddedDocument、 controlledframe 元素 target、DOMString type、USVString url、一个 可选字典 options，以及一个接受 布尔值的算法 completionSteps，运行以下步骤：

1. 令 permissionRequest 为一个新的 PermissionRequest 对象。

2. 如果 type 为 "media"：

   1. 令 requestController 为一个具有以下属性的新的 MediaPermissionRequestController：

      url

      url

3. 如果 type 为 "geolocation"：

   1. 令 requestController 为一个具有以下属性的新的 GeolocationPermissionRequestController：

      url

      url

4. 如果 type 为 "pointerLock"：

   1. 令 requestController 为一个具有以下属性的新的 PointerLockPermissionRequestController：

      lastUnlockedBySelf

      options["lastUnlockedBySelf"]

      userGesture

      options["userGesture"]

      url

      url

5. 如果 type 为 "download"：

   1. 令 requestController 为一个具有以下属性的新的 DownloadPermissionRequestController：

      requestMethod

      options["requestMethod"]

      url

      url

6. 如果 type 为 "filesystem"：

   1. 令 requestController 为一个具有以下属性的新的 FileSystemPermissionRequestController：

      url

      url

7. 如果 type 为 "fullscreen"：

   1. 令 requestController 为一个具有以下属性的新的 FullscreenPermissionRequestController：

      origin

      url 的源

8. 如果 type 为 "hid"：

   1. 令 requestController 为一个具有以下属性的新的 HidPermissionRequestController：

      url

      url

9. 设置 permissionRequest 的以下字段：

   request

   requestController

   permission

   type。

10. 将 e 的 permissionRequest 设置为 permissionRequest。

11. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以运行以下 步骤：

    1. 在 target 上分派 e。

    2. 在 embeddedDocument 的相关全局对象的 DOM 操作任务源上排队一个全局任务，该任务使用 e["permissionRequest"]["permission"]["allow"] 运行 completionSteps。

[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;
};

要触发一个 SizeChangedEvent e，给定 controlledframe 元素 target、4 个非负数 oldWidth、oldHeight、 newWidth、newHeight：

1. 令 sizeChange 为一个新的 SizeChange 对象。

2. 设置 sizeChange 的以下字段：

   oldWidth

   oldWidth。

   oldHeight

   oldHeight。

   newWidth

   newWidth。

   newHeight

   newHeight。

3. 将 e 的 sizeChange 设置为 sizeChange。

4. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 target 上分派 e。

[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;
};

要触发 ZoomChangeEvent e，给定 controlledframe 元素 target、2 个 浮点数 oldZoomFactor、newZoomFactor：

1. 令 zoomChange 为一个新的 ZoomChange 对象。

2. 设置 zoomChange 的以下字段：

   oldZoomFactor

   oldZoomFactor。

   newZoomFactor

   newZoomFactor。

3. 将 e 的 zoomChange 设置为 zoomChange。

4. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 target 上分派 e。

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

要触发 ContentLoadEvent e，给定 controlledframe 元素 target，运行以下步骤：

1. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 target 上分派 e。

[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;
};

要触发一个 LoadAbortEvent e，给定 controlledframe 元素 target、 一个 USVString url、一个布尔值 isTopLevel、一个 long code， 以及一个 DOMString reason，运行以下步骤：

1. 令 info 为一个具有以下属性的新的 LoadAbortInfo：

   url

   url

   isTopLevel

   isTopLevel

   code

   code

   reason

   reason

2. 将 e 的 loadAbortInfo 设置为 info。

3. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 target 上分派 e。

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

dictionary LoadCommitEventInit: EventInit {
  LoadInfo? loadInfo;
};

要触发一个 LoadCommitEvent e，给定 controlledframe 元素 target、 一个 USVString url 和一个布尔值 isTopLevel，运行以下步骤：

1. 令 info 为一个具有以下属性的新的 LoadInfo：

   url

   url

   isTopLevel

   isTopLevel

2. 将 e 的 loadInfo 设置为 info。

3. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 target 上分派 e。

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

dictionary LoadStartEventInit: EventInit {
  LoadInfo? loadInfo;
};

要触发一个 LoadStartEvent e，给定 controlledframe 元素 target、 一个 USVString url 和一个布尔值 isTopLevel，运行以下步骤：

1. 令 info 为一个具有以下属性的新的 LoadInfo：

   url

   url

   isTopLevel

   isTopLevel

2. 将 e 的 loadInfo 设置为 info。

3. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 target 上分派 e。

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

dictionary LoadStopEventInit: EventInit {
};

要触发 LoadStopEvent e ，给定 controlledframe 元素 target，运行以下步骤：

1. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 target 上分派 e。

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

dictionary LoadRedirectEventInit: EventInit {
  LoadRedirectInfo? loadRedirectInfo;
};

要触发 LoadRedirectEvent e，给定 controlledframe 元素 target、一个 URL oldUrl、一个 URL newUrl，以及一个布尔值 isTopLevel，运行 以下步骤：

1. 令 info 为一个具有以下属性的新的 LoadInfo：

   oldUrl

   给定 oldUrl，序列化 URL的结果

   newUrl

   给定 newUrl，序列化 URL的结果

   isTopLevel

   isTopLevel

2. 将 e 的 loadRedirectInfo 设置为 info。

3. 在 target 的相关全局对象的 DOM 操作任务源上排队一个全局任务，以在 target 上分派 e。

要确定一个 Document document 是否 被嵌入者允许使用某项 权限，给定 DOMString permission、一个可选字典 options，以及一个接受 布尔值的算法 completionSteps，运行以下步骤：

1. 令 controlledFrameEmbedderParent 为 document 的节点 navigable 的controlledFrameEmbedderParent。

2. 如果 controlledFrameEmbedderParent 不是 HTMLControlledFrameElement， 返回 true。

3. 使用 document、 controlledFrameEmbedderParent、permission、document 的 URL、options 和 completionSteps，触发 "permissionrequest" 事件。

要确定网络分区键，给定一个环境 environment：

4. 令 topLevelSite 为给定 topLevelOrigin，获取站点的结果。

5. 令 secondKey 为 null 或一个实现定义的值 。

6. 令 controlledFrameEmbedderParent 为给定 environment，获取环境的 controlledFrameEmbedderParent的结果。
7. 如果 controlledFrameEmbedderParent 不是 null，则将 secondKey 设置为一个元组，该元组由 controlledFrameEmbedderParent 的 相关设置对象的顶级源，以及 controlledFrameEmbedderParent 的 partition组成。

8. 返回 (topLevelSite, secondKey)。

要为非存储目的获取存储键，给定一个环境 environment，运行以下步骤：

1. 如果 environment 是一个环境设置对象，则令 origin 为 environment 的源；否则为 environment 的创建 URL的源。

2. 返回一个由 origin 组成的元组。
3. 令 topLevelOrigin 和 partition 为 null。
4. 令 controlledFrameEmbedderParent 为给定 environment，获取环境的 controlledFrameEmbedderParent的结果。
5. 如果 controlledFrameEmbedderParent 不是 null，则：
   1. 将 topLevelOrigin 设置为 controlledFrameEmbedderParent 的相关设置对象的顶级源。
   2. 将 partition 设置为 controlledFrameEmbedderParent 的 partition。
6. 返回一个由 topLevelOrigin、partition 和 origin 组成的元组。

要获取一个环境的 controlledFrameEmbedderParent，给定 一个环境 environment，运行以下步骤：

1. 如果 environment 是一个环境设置对象，其 全局对象是一个 Window 对象，则：

   此算法 不适用于 Shared 或 Service Workers，因为 controlledFrameEmbedderParent 仅 定义在 navigable 上，并且 并不总是可以从非 Window 环境到达一个 navigable。

   1. 令 navigable 为 environment 的全局对象的 navigable。

   2. 令 top 为 navigable 的顶级 traversable。

   3. 如果 top 的 controlledFrameEmbedderParent 不是 null，则返回 top 的 controlledFrameEmbedderParent。

2. 返回 null。

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

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

enum ConnectionState {
  "broken", "insecure", "secure"
};

dictionary Fingerprint {
  required DOMString sha256;
};

dictionary CertificateInfo {
  required Fingerprint fingerprint;
  Uint8Array rawDER;
};

dictionary SecurityInfo {
  required sequence<CertificateInfo> certificates;
  required ConnectionState state;
};

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

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

[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;
  readonly attribute SecurityInfo? securityInfo;

  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 {};

createWebRequestInterceptor(options) 方法步骤为：

1. 令 interceptor 为一个新的 WebRequestInterceptor 对象。

2. 在 interceptor 上设置以下字段：

   resourceTypes

   options["resourceTypes"]

   blocking

   options["blocking"]

   includeRequestBody

   options["includeRequestBody"]

   includeHeaders

   options["includeHeaders"]

   securityInfo

   options["securityInfo"]

   securityInfoRawDer

   options["securityInfoRawDer"]

3. 对于 options["urlPatterns"] 中的每个 urlPattern：

   1. 如果 urlPattern 是一个 URLPattern， 则将 urlPattern 追加到 interceptor 的 urlPatterns。

   2. 否则，给定 urlPattern，将一个新的 URLPattern 追加到 interceptor 的 urlPatterns。

4. 将 interceptor 追加到 this 的 拦截器。

5. 返回 interceptor。

要获取一个请求 request 的适用的 WebRequestInterceptor， 运行以下步骤：

1. 令 client 为 request 的客户端。

2. 如果 client 为 null，则返回一个空列表和 false。

3. 令 window 为给定 client，环境设置对象的所属 Window。

4. 如果 window 为 null，则返回一个空列表和 false。

5. 令 navigable 为 window 的navigable。

6. 如果 navigable 或其 controlledFrameEmbedderParent 为 null，则返回一个空列表 和 false。

7. 令 controlledFrame 为 navigable 的 controlledFrameEmbedderParent。

8. 令 applicableInterceptors 为空列表。

9. 对于 controlledFrame 的 request 的 拦截器中的每个 interceptor：

   1. 如果 request 不应被 interceptor 拦截， 则继续。

   2. 将 interceptor 追加到 applicableInterceptors。

10. 返回 applicableInterceptors。

要确定一个请求 request 是否应被一个 WebRequestInterceptor 拦截， 运行以下步骤：

1. 令 types 为 interceptor 的 resourceTypes。

2. 如果 types 不是空， 且 types 不 包含给定 request 调用获取请求的 ResourceType的结果，则返回 false。

3. 令 urlPatterns 为 interceptor 的 urlPatterns。

4. 对于 urlPatterns 中的每个 urlPattern：

   1. 如果 request 的 URL 给定 urlPattern 匹配一个 URLPattern，则返回 true。

5. 返回 false。

要获取一个环境设置对象的所属 Window， 给定一个环境设置对象 environment，运行 以下步骤：

1. 令 global 为 environment 的全局对象。

2. 如果 global 是一个 Window 对象，则返回 global。

3. 如果 global 是一个 DedicatedWorkerGlobalScope 对象，则：

   1. 令 owner 为 global。

   2. 当 owner 是一个 DedicatedWorkerGlobalScope 对象时：

      1. 令 owner 为 owner 的所有者集合[0]。

   3. 如果 owner 是一个 Document 对象，则返回 owner 的 相关全局对象。

4. 返回 null。

WebRequestAuthRequiredEvent 的 setCredentials(credentials, options) 方法步骤为：

1. 将 this 的 authCredentials 设置为 credentials。

2. 将 this 的 options 设置为 options。

WebRequestAuthRequiredEvent 的 preventDefault() 方法步骤为将 this 的 cancel 设置为 true。

WebRequestBeforeRequestEvent 的 redirect(redirectURL) 方法步骤为将 this 的 redirectURL 设置为 redirectURL。

WebRequestBeforeRequestEvent 的 preventDefault() 方法步骤为将 this 的 cancel 设置为 true。

WebRequestBeforeSendHeadersEvent 的 setRequestHeaders(requestHeaders) 方法步骤为将 this 的 requestHeaders 设置为 requestHeaders。

WebRequestBeforeSendHeadersEvent 的 preventDefault() 方法步骤为将 this 的 cancel 设置为 true。

WebRequestHeadersReceivedEvent 的 redirect(redirectURL) 方法步骤为将 this 的 redirectURL 设置为 redirectURL。

WebRequestHeadersReceivedEvent 的 setResponseHeaders(responseHeaders) 方法步骤为将 this 的 responseHeaders 设置为 responseHeaders。

WebRequestHeadersReceivedEvent 的 preventDefault() 方法步骤为将 this 的 cancel 设置为 true。

要处理 beforeRequest 事件，给定一个请求 request， 运行以下步骤：

1. 令 interceptors 为获取 request 的适用的 WebRequestInterceptors的结果。

2. 令 result 为一个 WebRequestEvent 结果。

3. 令 pendingHandlerCount 为 0。

4. 令 controlledFrameEmbedderGlobal 为给定 request 的客户端，获取环境的 controlledFrameEmbedderParent的结果的相关全局对象。

5. 如果 controlledFrameEmbedderGlobal 为 null，则返回。

6. 对于 interceptors 中的每个 interceptor：

   1. 如果 interceptor 的 blocking 为 true， 则递增 pendingHandlerCount。

   2. 在 controlledFrameEmbedderGlobal 的 DOM 操作任务源上排队一个全局任务，该任务将运行以下步骤：

      1. 令 event 为一个新的、名为 beforerequest 的 WebRequestBeforeRequestEvent。

      2. 给定 event、request 和 "none"，填充 WebRequestEvent。

      3. 如果 interceptor 的 includeRequestBody 为 true，且 request 的主体不是 null，则：

         1. 令 requestBody 为一个新的 RequestBody。

         2. 令 body 为 request 的主体。

            TODO：如果 body 的流存在，则对其进行序列化。

         3. 按 body 的源切换：

            字节序列

            将一个新的 UploadData 追加到 requestBody 的 raw，其 bytes 等于已序列化的 body 的源。

            Blob

            将一个新的 UploadData 追加到 requestBody 的 raw，其 bytes 等于已序列化的 body 的源。

            FormData

            1. 令 formData 为 «[]»。

            2. 对于 body 的源的 条目 列表中的每个 entry：

               1. 按 entry[1] 切换：

               File

               将一个新的 UploadData 追加到 requestBody 的 raw，其 file 等于 entry[1] 的 name。

               USVString

               1. 如果 formData[entry[0]] 不存在，则将 formData[entry[0]] 设置为空列表。

               2. 将 entry[1] 追加到 formData[entry[0]]。

            3. 将 requestBody 的 formData 设置为 formData。

         4. 将 event 的 request 的 body 设置为 requestBody。

      4. 将 event 分派给 interceptor。

      5. 如果 event 的 cancel 为 true， 则将 result 的 cancel 设置为 true。

      6. 如果 event 的 redirectURL 不为 null，且 result 的 redirectURL 为 ""， 则将 result 的 redirectURL 设置为 event 的 redirectURL。

      7. 如果 interceptor 的 blocking 为 true， 则递减 pendingHandlerCount。

7. 如果 pendingHandlerCount > 0，则并行等待 pendingHandlerCount 等于 0，然后排队一个全局任务，该任务将在 request 的客户端的全局对象的网络任务源，或这些步骤最初被调用所在的 并行上下文上继续运行此算法的剩余步骤， 具体取决于这些步骤在进入并行之前是如何运行的。

8. 返回 result。