devtools-tracing 1.0.0

package/lib/front_end/core/sdk/Script.ts

@@ -0,0 +1,534 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import type * as Platform from '../../core/platform/platform.js';
+import * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import * as Common from '../common/common.js';
+import * as i18n from '../i18n/i18n.js';
+
+import {
+  COND_BREAKPOINT_SOURCE_URL,
+  type DebuggerModel,
+  Events,
+  Location,
+  LOGPOINT_SOURCE_URL,
+} from './DebuggerModel.js';
+import type {FrameAssociated} from './FrameAssociated.js';
+import type {PageResourceLoadInitiator} from './PageResourceLoader.js';
+import {ResourceTreeModel} from './ResourceTreeModel.js';
+import type {ExecutionContext} from './RuntimeModel.js';
+import type {DebugId, SourceMap} from './SourceMap.js';
+import type {Target} from './Target.js';
+
+const UIStrings = {
+  /**
+   * @description Error message for when a script can't be loaded which had been previously
+   */
+  scriptRemovedOrDeleted: 'Script removed or deleted.',
+  /**
+   * @description Error message when failing to load a script source text
+   */
+  unableToFetchScriptSource: 'Unable to fetch script source.',
+} as const;
+const str_ = i18n.i18n.registerUIStrings('core/sdk/Script.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+
+let scriptCacheInstance: {
+  cache: Map<string, WeakRef<Promise<TextUtils.ContentData.ContentDataOrError>>>,
+  registry: FinalizationRegistry<string>,
+}|null = null;
+
+export class Script implements TextUtils.ContentProvider.ContentProvider, FrameAssociated {
+  debuggerModel: DebuggerModel;
+  scriptId: Protocol.Runtime.ScriptId;
+  /**
+   * The URL of the script. When `hasSourceURL` is true, this value comes from a `//# sourceURL=` directive. Otherwise,
+   * it's the original `src` URL from which the script was loaded.
+   */
+  sourceURL: Platform.DevToolsPath.UrlString;
+  lineOffset: number;
+  columnOffset: number;
+  endLine: number;
+  endColumn: number;
+  executionContextId: number;
+  hash: string;
+  readonly #isContentScript: boolean;
+  readonly #isLiveEdit: boolean;
+  sourceMapURL?: string;
+  debugSymbols: Protocol.Debugger.DebugSymbols|null;
+  hasSourceURL: boolean;
+  contentLength: number;
+  originStackTrace: Protocol.Runtime.StackTrace|null;
+  readonly #codeOffset: number|null;
+  readonly #language: string|null;
+  #contentPromise: Promise<TextUtils.ContentData.ContentDataOrError>|null;
+  readonly #embedderName: Platform.DevToolsPath.UrlString|null;
+  readonly isModule: boolean|null;
+  readonly buildId: string|null;
+  constructor(
+      debuggerModel: DebuggerModel, scriptId: Protocol.Runtime.ScriptId, sourceURL: Platform.DevToolsPath.UrlString,
+      startLine: number, startColumn: number, endLine: number, endColumn: number, executionContextId: number,
+      hash: string, isContentScript: boolean, isLiveEdit: boolean, sourceMapURL: string|undefined,
+      hasSourceURL: boolean, length: number, isModule: boolean|null, originStackTrace: Protocol.Runtime.StackTrace|null,
+      codeOffset: number|null, scriptLanguage: string|null, debugSymbols: Protocol.Debugger.DebugSymbols|null,
+      embedderName: Platform.DevToolsPath.UrlString|null, buildId: string|null) {
+    this.debuggerModel = debuggerModel;
+    this.scriptId = scriptId;
+    this.sourceURL = sourceURL;
+    this.lineOffset = startLine;
+    this.columnOffset = startColumn;
+    this.endLine = endLine;
+    this.endColumn = endColumn;
+    this.isModule = isModule;
+    this.buildId = buildId;
+
+    this.executionContextId = executionContextId;
+    this.hash = hash;
+    this.#isContentScript = isContentScript;
+    this.#isLiveEdit = isLiveEdit;
+    this.sourceMapURL = sourceMapURL;
+    this.debugSymbols = debugSymbols;
+    this.hasSourceURL = hasSourceURL;
+    this.contentLength = length;
+    this.originStackTrace = originStackTrace;
+    this.#codeOffset = codeOffset;
+    this.#language = scriptLanguage;
+    this.#contentPromise = null;
+    this.#embedderName = embedderName;
+  }
+
+  embedderName(): Platform.DevToolsPath.UrlString|null {
+    return this.#embedderName;
+  }
+
+  target(): Target {
+    return this.debuggerModel.target();
+  }
+
+  private static trimSourceURLComment(source: string): string {
+    let sourceURLIndex = source.lastIndexOf('//# sourceURL=');
+    if (sourceURLIndex === -1) {
+      sourceURLIndex = source.lastIndexOf('//@ sourceURL=');
+      if (sourceURLIndex === -1) {
+        return source;
+      }
+    }
+    const sourceURLLineIndex = source.lastIndexOf('\n', sourceURLIndex);
+    if (sourceURLLineIndex === -1) {
+      return source;
+    }
+    const sourceURLLine = source.substr(sourceURLLineIndex + 1);
+    if (!sourceURLLine.match(sourceURLRegex)) {
+      return source;
+    }
+    return source.substr(0, sourceURLLineIndex);
+  }
+
+  isContentScript(): boolean {
+    return this.#isContentScript;
+  }
+
+  codeOffset(): number|null {
+    return this.#codeOffset;
+  }
+
+  isJavaScript(): boolean {
+    return this.#language === Protocol.Debugger.ScriptLanguage.JavaScript;
+  }
+
+  isWasm(): boolean {
+    return this.#language === Protocol.Debugger.ScriptLanguage.WebAssembly;
+  }
+
+  scriptLanguage(): string|null {
+    return this.#language;
+  }
+
+  executionContext(): ExecutionContext|null {
+    return this.debuggerModel.runtimeModel().executionContext(this.executionContextId);
+  }
+
+  isLiveEdit(): boolean {
+    return this.#isLiveEdit;
+  }
+
+  contentURL(): Platform.DevToolsPath.UrlString {
+    return this.sourceURL;
+  }
+
+  contentType(): Common.ResourceType.ResourceType {
+    return Common.ResourceType.resourceTypes.Script;
+  }
+
+  private async loadTextContent(): Promise<TextUtils.ContentData.ContentData> {
+    const result = await this.debuggerModel.target().debuggerAgent().invoke_getScriptSource({scriptId: this.scriptId});
+    if (result.getError()) {
+      throw new Error(result.getError());
+    }
+    const {scriptSource, bytecode} = result;
+    if (bytecode) {
+      return new TextUtils.ContentData.ContentData(bytecode, /* isBase64 */ true, 'application/wasm');
+    }
+    let content: string = scriptSource || '';
+    if (this.hasSourceURL && Common.ParsedURL.schemeIs(this.sourceURL, 'snippet:')) {
+      // TODO(crbug.com/1330846): Find a better way to establish the snippet automapping binding then adding
+      // a sourceURL comment before evaluation and removing it here.
+      content = Script.trimSourceURLComment(content);
+    }
+    return new TextUtils.ContentData.ContentData(content, /* isBase64 */ false, 'text/javascript');
+  }
+
+  private async loadWasmContent(): Promise<TextUtils.ContentData.ContentDataOrError> {
+    if (!this.isWasm()) {
+      throw new Error('Not a wasm script');
+    }
+    const result =
+        await this.debuggerModel.target().debuggerAgent().invoke_disassembleWasmModule({scriptId: this.scriptId});
+
+    if (result.getError()) {
+      // Fall through to text content loading if v8-based disassembly fails. This is to ensure backwards compatibility with
+      // older v8 versions.
+      const contentData = await this.loadTextContent();
+      return await disassembleWasm(contentData.base64);
+    }
+
+    const {streamId, functionBodyOffsets, chunk: {lines, bytecodeOffsets}} = result;
+    const lineChunks = [];
+    const bytecodeOffsetChunks = [];
+    let totalLength = lines.reduce<number>((sum, line) => sum + line.length + 1, 0);
+    const truncationMessage = '<truncated>';
+    // This is a magic number used in code mirror which, when exceeded, sends it into an infinite loop.
+    const cmSizeLimit = 1000000000 - truncationMessage.length;
+    if (streamId) {
+      while (true) {
+        const result = await this.debuggerModel.target().debuggerAgent().invoke_nextWasmDisassemblyChunk({streamId});
+
+        if (result.getError()) {
+          throw new Error(result.getError());
+        }
+
+        const {chunk: {lines: linesChunk, bytecodeOffsets: bytecodeOffsetsChunk}} = result;
+        totalLength += linesChunk.reduce<number>((sum, line) => sum + line.length + 1, 0);
+        if (linesChunk.length === 0) {
+          break;
+        }
+        if (totalLength >= cmSizeLimit) {
+          lineChunks.push([truncationMessage]);
+          bytecodeOffsetChunks.push([0]);
+          break;
+        }
+
+        lineChunks.push(linesChunk);
+        bytecodeOffsetChunks.push(bytecodeOffsetsChunk);
+      }
+    }
+    const functionBodyRanges: Array<{start: number, end: number}> = [];
+    // functionBodyOffsets contains a sequence of pairs of start and end offsets
+    for (let i = 0; i < functionBodyOffsets.length; i += 2) {
+      functionBodyRanges.push({start: functionBodyOffsets[i], end: functionBodyOffsets[i + 1]});
+    }
+    return new TextUtils.WasmDisassembly.WasmDisassembly(
+        lines.concat(...lineChunks), bytecodeOffsets.concat(...bytecodeOffsetChunks), functionBodyRanges);
+  }
+
+  requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError> {
+    if (!this.#contentPromise) {
+      const fileSizeToCache = 65535;  // We won't bother cacheing files under 64K
+      if (this.hash && !this.#isLiveEdit && this.contentLength > fileSizeToCache) {
+        // For large files that aren't live edits and have a hash, we keep a content-addressed cache
+        // so we don't need to load multiple copies or disassemble wasm modules multiple times.
+        if (!scriptCacheInstance) {
+          // Initialize script cache singleton. Add a finalizer for removing keys from the map.
+          scriptCacheInstance = {
+            cache: new Map(),
+            registry: new FinalizationRegistry(hashCode => scriptCacheInstance?.cache.delete(hashCode)),
+          };
+        }
+        // This key should be sufficient to identify scripts that are known to have the same content.
+        const fullHash = [
+          this.#language,
+          this.contentLength,
+          this.lineOffset,
+          this.columnOffset,
+          this.endLine,
+          this.endColumn,
+          this.#codeOffset,
+          this.hash,
+        ].join(':');
+        const cachedContentPromise = scriptCacheInstance.cache.get(fullHash)?.deref();
+        if (cachedContentPromise) {
+          this.#contentPromise = cachedContentPromise;
+        } else {
+          this.#contentPromise = this.#requestContent();
+          scriptCacheInstance.cache.set(fullHash, new WeakRef(this.#contentPromise));
+          scriptCacheInstance.registry.register(this.#contentPromise, fullHash);
+        }
+      } else {
+        this.#contentPromise = this.#requestContent();
+      }
+    }
+    return this.#contentPromise;
+  }
+
+  async #requestContent(): Promise<TextUtils.ContentData.ContentDataOrError> {
+    if (!this.scriptId) {
+      return {error: i18nString(UIStrings.scriptRemovedOrDeleted)};
+    }
+    try {
+      return this.isWasm() ? await this.loadWasmContent() : await this.loadTextContent();
+    } catch {
+      // TODO(bmeurer): Propagate errors as exceptions / rejections.
+      return {error: i18nString(UIStrings.unableToFetchScriptSource)};
+    }
+  }
+
+  async getWasmBytecode(): Promise<ArrayBuffer> {
+    const base64 = await this.debuggerModel.target().debuggerAgent().invoke_getWasmBytecode({scriptId: this.scriptId});
+    const response = await fetch(`data:application/wasm;base64,${base64.bytecode}`);
+    return await response.arrayBuffer();
+  }
+
+  originalContentProvider(): TextUtils.ContentProvider.ContentProvider {
+    return new TextUtils.StaticContentProvider.StaticContentProvider(
+        this.contentURL(), this.contentType(), () => this.requestContentData());
+  }
+
+  async searchInContent(query: string, caseSensitive: boolean, isRegex: boolean):
+      Promise<TextUtils.ContentProvider.SearchMatch[]> {
+    if (!this.scriptId) {
+      return [];
+    }
+
+    const matches = await this.debuggerModel.target().debuggerAgent().invoke_searchInContent(
+        {scriptId: this.scriptId, query, caseSensitive, isRegex});
+    return TextUtils.TextUtils.performSearchInSearchMatches(matches.result || [], query, caseSensitive, isRegex);
+  }
+
+  private appendSourceURLCommentIfNeeded(source: string): string {
+    if (!this.hasSourceURL) {
+      return source;
+    }
+    return source + '\n //# sourceURL=' + this.sourceURL;
+  }
+
+  async editSource(newSource: string): Promise<{
+    changed: boolean,
+    status: Protocol.Debugger.SetScriptSourceResponseStatus,
+    exceptionDetails?: Protocol.Runtime.ExceptionDetails,
+  }> {
+    newSource = Script.trimSourceURLComment(newSource);
+    // We append correct #sourceURL to script for consistency only. It's not actually needed for things to work correctly.
+    newSource = this.appendSourceURLCommentIfNeeded(newSource);
+
+    const oldSource = TextUtils.ContentData.ContentData.textOr(await this.requestContentData(), null);
+    if (oldSource === newSource) {
+      return {changed: false, status: Protocol.Debugger.SetScriptSourceResponseStatus.Ok};
+    }
+    const response = await this.debuggerModel.target().debuggerAgent().invoke_setScriptSource(
+        {scriptId: this.scriptId, scriptSource: newSource, allowTopFrameEditing: true});
+    if (response.getError()) {
+      // Something went seriously wrong, like the V8 inspector no longer knowing about this script without
+      // shutting down the Debugger agent etc.
+      throw new Error(`Script#editSource failed for script with id ${this.scriptId}: ${response.getError()}`);
+    }
+
+    if (!response.getError() && response.status === Protocol.Debugger.SetScriptSourceResponseStatus.Ok) {
+      this.#contentPromise =
+          Promise.resolve(new TextUtils.ContentData.ContentData(newSource, /* isBase64 */ false, 'text/javascript'));
+    }
+
+    this.debuggerModel.dispatchEventToListeners(Events.ScriptSourceWasEdited, {script: this, status: response.status});
+    return {changed: true, status: response.status, exceptionDetails: response.exceptionDetails};
+  }
+
+  rawLocation(lineNumber: number, columnNumber: number): Location|null {
+    if (this.containsLocation(lineNumber, columnNumber)) {
+      return new Location(this.debuggerModel, this.scriptId, lineNumber, columnNumber);
+    }
+    return null;
+  }
+
+  isInlineScript(): boolean {
+    const startsAtZero = !this.lineOffset && !this.columnOffset;
+    return !this.isWasm() && Boolean(this.sourceURL) && !startsAtZero;
+  }
+
+  isAnonymousScript(): boolean {
+    return !this.sourceURL;
+  }
+
+  async setBlackboxedRanges(positions: Protocol.Debugger.ScriptPosition[]): Promise<boolean> {
+    const response = await this.debuggerModel.target().debuggerAgent().invoke_setBlackboxedRanges(
+        {scriptId: this.scriptId, positions});
+    return !response.getError();
+  }
+
+  containsLocation(lineNumber: number, columnNumber: number): boolean {
+    const afterStart =
+        (lineNumber === this.lineOffset && columnNumber >= this.columnOffset) || lineNumber > this.lineOffset;
+    const beforeEnd = lineNumber < this.endLine || (lineNumber === this.endLine && columnNumber <= this.endColumn);
+    return afterStart && beforeEnd;
+  }
+
+  get frameId(): Protocol.Page.FrameId {
+    // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
+    // @ts-expect-error
+    if (typeof this[frameIdSymbol] !== 'string') {
+      // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
+      // @ts-expect-error
+      this[frameIdSymbol] = frameIdForScript(this);
+    }
+    // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
+    // @ts-expect-error
+    return this[frameIdSymbol];
+  }
+
+  /**
+   * @returns true, iff this script originates from a breakpoint/logpoint condition
+   */
+  get isBreakpointCondition(): boolean {
+    return [COND_BREAKPOINT_SOURCE_URL, LOGPOINT_SOURCE_URL].includes(this.sourceURL);
+  }
+
+  /**
+   * @returns the currently attached source map for this Script or `undefined` if there is none or it
+   * hasn't loaded yet.
+   */
+  sourceMap(): SourceMap|undefined {
+    return this.debuggerModel.sourceMapManager().sourceMapForClient(this);
+  }
+
+  createPageResourceLoadInitiator(): PageResourceLoadInitiator {
+    return {target: this.target(), frameId: this.frameId, initiatorUrl: this.embedderName()};
+  }
+
+  debugId(): DebugId|null {
+    return this.buildId as (DebugId | null);
+  }
+
+  /**
+   * Translates the `rawLocation` from line and column number in terms of what V8 understands
+   * to a script relative location. Specifically this means that for inline `<script>`'s
+   * without a `//# sourceURL=` annotation, the line and column offset of the script
+   * content is subtracted to make the location within the script independent of the
+   * location of the `<script>` tag within the surrounding document.
+   *
+   * @param rawLocation the raw location in terms of what V8 understands.
+   * @returns the script relative line and column number for the {@link rawLocation}.
+   */
+  rawLocationToRelativeLocation(rawLocation: {lineNumber: number, columnNumber: number}):
+      {lineNumber: number, columnNumber: number};
+  rawLocationToRelativeLocation(rawLocation: {lineNumber: number, columnNumber: number|undefined}):
+      {lineNumber: number, columnNumber: number|undefined};
+  rawLocationToRelativeLocation(rawLocation: {lineNumber: number, columnNumber: number|undefined}):
+      {lineNumber: number, columnNumber: number|undefined} {
+    let {lineNumber, columnNumber} = rawLocation;
+    if (!this.hasSourceURL && this.isInlineScript()) {
+      lineNumber -= this.lineOffset;
+      if (lineNumber === 0 && columnNumber !== undefined) {
+        columnNumber -= this.columnOffset;
+      }
+    }
+    return {lineNumber, columnNumber};
+  }
+
+  /**
+   * Translates the `relativeLocation` from script relative line and column number to
+   * the raw location in terms of what V8 understands. Specifically this means that for
+   * inline `<script>`'s without a `//# sourceURL=` annotation, the line and column offset
+   * of the script content is added to make the location relative to the start of the
+   * surrounding document.
+   *
+   * @param relativeLocation the script relative location.
+   * @returns the raw location in terms of what V8 understands for the {@link relativeLocation}.
+   */
+  relativeLocationToRawLocation(relativeLocation: {lineNumber: number, columnNumber: number}):
+      {lineNumber: number, columnNumber: number};
+  relativeLocationToRawLocation(relativeLocation: {lineNumber: number, columnNumber: number|undefined}):
+      {lineNumber: number, columnNumber: number|undefined};
+  relativeLocationToRawLocation(relativeLocation: {lineNumber: number, columnNumber: number|undefined}):
+      {lineNumber: number, columnNumber: number|undefined} {
+    let {lineNumber, columnNumber} = relativeLocation;
+    if (!this.hasSourceURL && this.isInlineScript()) {
+      if (lineNumber === 0 && columnNumber !== undefined) {
+        columnNumber += this.columnOffset;
+      }
+      lineNumber += this.lineOffset;
+    }
+    return {lineNumber, columnNumber};
+  }
+}
+
+const frameIdSymbol = Symbol('frameid');
+
+function frameIdForScript(script: Script): Protocol.Page.FrameId|null {
+  const executionContext = script.executionContext();
+  if (executionContext) {
+    return executionContext.frameId || null;
+  }
+  // This is to overcome compilation cache which doesn't get reset.
+  const resourceTreeModel = script.debuggerModel.target().model(ResourceTreeModel);
+  if (!resourceTreeModel?.mainFrame) {
+    return null;
+  }
+  return resourceTreeModel.mainFrame.id;
+}
+
+export const sourceURLRegex = /^[\x20\t]*\/\/[@#] sourceURL=\s*(\S*?)\s*$/;
+
+export async function disassembleWasm(content: string): Promise<TextUtils.WasmDisassembly.WasmDisassembly> {
+  const worker = Common.Worker.WorkerWrapper.fromURL(
+      new URL('../../entrypoints/wasmparser_worker/wasmparser_worker-entrypoint.js', import.meta.url));
+  const promise = new Promise<TextUtils.WasmDisassembly.WasmDisassembly>((resolve, reject) => {
+    worker.onmessage = ({data}: MessageEvent) => {
+      if ('method' in data) {
+        switch (data.method) {
+          case 'disassemble':
+            if ('error' in data) {
+              reject(data.error);
+            } else if ('result' in data) {
+              const {lines, offsets, functionBodyOffsets} = data.result;
+              resolve(new TextUtils.WasmDisassembly.WasmDisassembly(lines, offsets, functionBodyOffsets));
+            }
+            break;
+        }
+      }
+    };
+    worker.onerror = reject;
+  });
+
+  worker.postMessage({method: 'disassemble', params: {content}});
+
+  try {
+    return await promise;  // The await is important here or we terminate the worker too early.
+  } finally {
+    worker.terminate();
+  }
+}

package/lib/front_end/core/sdk/SecurityOriginManager.ts

@@ -0,0 +1,76 @@
+// Copyright 2016 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import {SDKModel} from './SDKModel.js';
+import {Capability} from './Target.js';
+
+export class SecurityOriginManager extends SDKModel<EventTypes> {
+  // if a URL is unreachable, the browser will jump to an error page at
+  // 'chrome-error://chromewebdata/', and |this.#mainSecurityOriginInternal| stores
+  // its origin. In this situation, the original unreachable URL's security
+  // origin will be stored in |this.#unreachableMainSecurityOriginInternal|.
+  #mainSecurityOrigin = '';
+  #unreachableMainSecurityOrigin: string|null = '';
+  #securityOrigins = new Set<string>();
+
+  updateSecurityOrigins(securityOrigins: Set<string>): void {
+    const oldOrigins = this.#securityOrigins;
+    this.#securityOrigins = securityOrigins;
+
+    for (const origin of oldOrigins) {
+      if (!this.#securityOrigins.has(origin)) {
+        this.dispatchEventToListeners(Events.SecurityOriginRemoved, origin);
+      }
+    }
+
+    for (const origin of this.#securityOrigins) {
+      if (!oldOrigins.has(origin)) {
+        this.dispatchEventToListeners(Events.SecurityOriginAdded, origin);
+      }
+    }
+  }
+
+  securityOrigins(): string[] {
+    return [...this.#securityOrigins];
+  }
+
+  mainSecurityOrigin(): string {
+    return this.#mainSecurityOrigin;
+  }
+
+  unreachableMainSecurityOrigin(): string|null {
+    return this.#unreachableMainSecurityOrigin;
+  }
+
+  setMainSecurityOrigin(securityOrigin: string, unreachableSecurityOrigin: string): void {
+    this.#mainSecurityOrigin = securityOrigin;
+    this.#unreachableMainSecurityOrigin = unreachableSecurityOrigin || null;
+    this.dispatchEventToListeners(Events.MainSecurityOriginChanged, {
+      mainSecurityOrigin: this.#mainSecurityOrigin,
+      unreachableMainSecurityOrigin: this.#unreachableMainSecurityOrigin,
+    });
+  }
+}
+
+export enum Events {
+  /* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
+  SecurityOriginAdded = 'SecurityOriginAdded',
+  SecurityOriginRemoved = 'SecurityOriginRemoved',
+  MainSecurityOriginChanged = 'MainSecurityOriginChanged',
+  /* eslint-enable @typescript-eslint/naming-convention */
+}
+
+export interface MainSecurityOriginChangedEvent {
+  mainSecurityOrigin: string;
+  unreachableMainSecurityOrigin: string|null;
+}
+
+export interface EventTypes {
+  [Events.SecurityOriginAdded]: string;
+  [Events.SecurityOriginRemoved]: string;
+  [Events.MainSecurityOriginChanged]: MainSecurityOriginChangedEvent;
+}
+
+// TODO(jarhar): this is the one of the two usages of Capability.None. Do something about it!
+SDKModel.register(SecurityOriginManager, {capabilities: Capability.NONE, autostart: false});

package/lib/front_end/core/sdk/ServerSentEvents.ts

@@ -0,0 +1,80 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+
+import {Events, type EventSourceMessage, type NetworkRequest} from './NetworkRequest.js';
+import {ServerSentEventsParser} from './ServerSentEventsProtocol.js';
+
+/**
+ * Server sent events only arrive via CDP (Explicit Network.eventSourceMessageReceived) when
+ * the page uses "EventSource" in the code.
+ *
+ * If the page manually uses 'fetch' or XHR we have to do the protocol parsing
+ * ourselves.
+ *
+ * `ServerSentEvents` is a small helper class that manages this distinction for a specific
+ * request, stores the event data and sends out "EventSourceMessageAdded" events for a request.
+ */
+export class ServerSentEvents {
+  readonly #request: NetworkRequest;
+  readonly #parser?: ServerSentEventsParser;
+
+  // In the case where we parse the events ourselves we use the time of the last 'dataReceived'
+  // event for all the events that come out of the corresponding chunk of data.
+  #lastDataReceivedTime = 0;
+
+  readonly #eventSourceMessages: EventSourceMessage[] = [];
+
+  constructor(request: NetworkRequest, parseFromStreamedData: boolean) {
+    this.#request = request;
+
+    // Only setup parsing if we don't get the events over CDP directly.
+    if (parseFromStreamedData) {
+      this.#lastDataReceivedTime = request.pseudoWallTime(request.startTime);
+      this.#parser = new ServerSentEventsParser(this.#onParserEvent.bind(this), request.charset() ?? undefined);
+
+      // Get the streaming content and add the already received bytes if someone else started
+      // the streaming earlier.
+      void this.#request.requestStreamingContent().then(streamingContentData => {
+        if (!TextUtils.StreamingContentData.isError(streamingContentData)) {
+          void this.#parser?.addBase64Chunk(streamingContentData.content().base64);
+          streamingContentData.addEventListener(
+              TextUtils.StreamingContentData.Events.CHUNK_ADDED, ({data: {chunk}}) => {
+                this.#lastDataReceivedTime = request.pseudoWallTime(request.endTime);
+                void this.#parser?.addBase64Chunk(chunk);
+              });
+        }
+      });
+    }
+  }
+
+  get eventSourceMessages(): readonly EventSourceMessage[] {
+    return this.#eventSourceMessages;
+  }
+
+  /** Forwarded Network.eventSourceMessage received */
+  onProtocolEventSourceMessageReceived(eventName: string, data: string, eventId: string, time: number): void {
+    this.#recordMessageAndDispatchEvent({
+      eventName,
+      eventId,
+      data,
+      time,
+    });
+  }
+
+  #onParserEvent(eventName: string, data: string, eventId: string): void {
+    this.#recordMessageAndDispatchEvent({
+      eventName,
+      eventId,
+      data,
+      time: this.#lastDataReceivedTime,
+    });
+  }
+
+  #recordMessageAndDispatchEvent(message: EventSourceMessage): void {
+    this.#eventSourceMessages.push(message);
+    this.#request.dispatchEventToListeners(Events.EVENT_SOURCE_MESSAGE_ADDED, message);
+  }
+}