devtools-tracing 1.0.0

package/lib/front_end/models/formatter/FormatterWorkerPool.ts

@@ -0,0 +1,219 @@
+// 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 * as Common from '../../core/common/common.js';
+import * as FormatterActions from '../../entrypoints/formatter_worker/FormatterActions.js';  // eslint-disable-line @devtools/es-modules-import
+
+export {DefinitionKind, ScopeKind, type ScopeTreeNode} from '../../entrypoints/formatter_worker/FormatterActions.js';
+
+let formatterWorkerPoolInstance: FormatterWorkerPool|undefined;
+
+export class FormatterWorkerPool {
+  private taskQueue: Task[];
+  private workerTasks: Map<Common.Worker.WorkerWrapper, Task|null>;
+
+  constructor() {
+    this.taskQueue = [];
+    this.workerTasks = new Map();
+  }
+
+  static instance(): FormatterWorkerPool {
+    if (!formatterWorkerPoolInstance) {
+      formatterWorkerPoolInstance = new FormatterWorkerPool();
+    }
+
+    return formatterWorkerPoolInstance;
+  }
+
+  dispose(): void {
+    for (const task of this.taskQueue) {
+      console.error('rejecting task');
+      task.errorCallback(new Event('Worker terminated'));
+    }
+    for (const [worker, task] of this.workerTasks.entries()) {
+      task?.errorCallback(new Event('Worker terminated'));
+      worker.terminate(/* immediately=*/ true);
+    }
+  }
+
+  static removeInstance(): void {
+    formatterWorkerPoolInstance?.dispose();
+    formatterWorkerPoolInstance = undefined;
+  }
+
+  private createWorker(): Common.Worker.WorkerWrapper {
+    const worker = Common.Worker.WorkerWrapper.fromURL(
+        new URL('../../entrypoints/formatter_worker/formatter_worker-entrypoint.js', import.meta.url));
+    worker.onmessage = this.onWorkerMessage.bind(this, worker);
+    worker.onerror = this.onWorkerError.bind(this, worker);
+    return worker;
+  }
+
+  private processNextTask(): void {
+    const maxWorkers = Math.max(2, navigator.hardwareConcurrency - 1);
+
+    if (!this.taskQueue.length) {
+      return;
+    }
+
+    let freeWorker = [...this.workerTasks.keys()].find(worker => !this.workerTasks.get(worker));
+    if (!freeWorker && this.workerTasks.size < maxWorkers) {
+      freeWorker = this.createWorker();
+    }
+    if (!freeWorker) {
+      return;
+    }
+
+    const task = this.taskQueue.shift();
+    if (task) {
+      this.workerTasks.set(freeWorker, task);
+      freeWorker.postMessage({method: task.method, params: task.params});
+    }
+  }
+
+  private onWorkerMessage(worker: Common.Worker.WorkerWrapper, event: MessageEvent): void {
+    const task = this.workerTasks.get(worker);
+    if (!task) {
+      return;
+    }
+    if (task.isChunked && event.data && !event.data['isLastChunk']) {
+      task.callback(event.data);
+      return;
+    }
+
+    this.workerTasks.set(worker, null);
+    this.processNextTask();
+    task.callback(event.data ? event.data : null);
+  }
+
+  private onWorkerError(worker: Common.Worker.WorkerWrapper, event: Event): void {
+    console.error(event);
+    const task = this.workerTasks.get(worker);
+    worker.terminate();
+    this.workerTasks.delete(worker);
+
+    const newWorker = this.createWorker();
+    this.workerTasks.set(newWorker, null);
+    this.processNextTask();
+    if (task) {
+      task.errorCallback(event);
+    }
+  }
+
+  private runChunkedTask(
+      methodName: string, params: Record<string, string>, callback: (arg0: boolean, arg1: unknown) => void): void {
+    const task = new Task(methodName, params, onData, () => onData(null), true);
+    this.taskQueue.push(task);
+    this.processNextTask();
+
+    function onData(data: Object|null): void {
+      if (!data) {
+        callback(true, null);
+        return;
+      }
+      const isLastChunk = 'isLastChunk' in data && Boolean(data['isLastChunk']);
+      const chunk = 'chunk' in data && data['chunk'];
+      callback(isLastChunk, chunk);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private runTask(methodName: FormatterActions.FormatterActions, params: Record<string, unknown>): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const task = new Task(methodName, params, resolve, reject, false);
+      this.taskQueue.push(task);
+      this.processNextTask();
+    });
+  }
+
+  format(mimeType: string, content: string, indentString: string): Promise<FormatterActions.FormatResult> {
+    const parameters = {mimeType, content, indentString};
+    return this.runTask(FormatterActions.FormatterActions.FORMAT, parameters) as Promise<FormatterActions.FormatResult>;
+  }
+
+  javaScriptSubstitute(expression: string, mapping: Map<string, string|null>): Promise<string> {
+    if (mapping.size === 0) {
+      return Promise.resolve(expression);
+    }
+    return this.runTask(FormatterActions.FormatterActions.JAVASCRIPT_SUBSTITUTE, {content: expression, mapping})
+        .then(result => result || '');
+  }
+
+  javaScriptScopeTree(expression: string, sourceType: 'module'|'script' = 'script'):
+      Promise<FormatterActions.ScopeTreeNode|null> {
+    return this.runTask(FormatterActions.FormatterActions.JAVASCRIPT_SCOPE_TREE, {content: expression, sourceType})
+        .then(result => result || null);
+  }
+
+  parseCSS(content: string, callback: (arg0: boolean, arg1: CSSRule[]) => void): void {
+    this.runChunkedTask(FormatterActions.FormatterActions.PARSE_CSS, {content}, onDataChunk);
+
+    // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function onDataChunk(isLastChunk: boolean, data: any): void {
+      const rules = (data || [] as CSSRule[]);
+      callback(isLastChunk, rules);
+    }
+  }
+}
+
+class Task {
+  method: string;
+  params: unknown;
+  callback: (arg0: MessageEvent|null) => void;
+  errorCallback: (arg0: Event) => void;
+  isChunked: boolean|undefined;
+  constructor(
+      method: string, params: unknown, callback: (arg0: MessageEvent|null) => void,
+      errorCallback: (arg0: Event) => void, isChunked?: boolean) {
+    this.method = method;
+    this.params = params;
+    this.callback = callback;
+    this.errorCallback = errorCallback;
+    this.isChunked = isChunked;
+  }
+}
+
+interface CSSProperty {
+  name: string;
+  nameRange: TextRange;
+  value: string;
+  valueRange: TextRange;
+  range: TextRange;
+  disabled?: boolean;
+}
+
+export function formatterWorkerPool(): FormatterWorkerPool {
+  return FormatterWorkerPool.instance();
+}
+
+export interface OutlineItem {
+  line: number;
+  column: number;
+  title: string;
+  subtitle?: string;
+}
+
+export interface CSSStyleRule {
+  selectorText: string;
+  styleRange: TextRange;
+  lineNumber: number;
+  columnNumber: number;
+  properties: CSSProperty[];
+}
+
+export interface CSSAtRule {
+  atRule: string;
+  lineNumber: number;
+  columnNumber: number;
+}
+
+export type CSSRule = CSSStyleRule|CSSAtRule;
+
+export interface TextRange {
+  startLine: number;
+  startColumn: number;
+  endLine: number;
+  endColumn: number;
+}

package/lib/front_end/models/formatter/ScriptFormatter.ts

@@ -0,0 +1,112 @@
+// Copyright 2011 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 Common from '../../core/common/common.js';
+import * as Platform from '../../core/platform/platform.js';
+import type * as FormatterActions from '../../entrypoints/formatter_worker/FormatterActions.js';
+
+import {formatterWorkerPool} from './FormatterWorkerPool.js';
+
+function locationToPosition(lineEndings: number[], lineNumber: number, columnNumber: number): number {
+  const position = lineNumber ? lineEndings[lineNumber - 1] + 1 : 0;
+  return position + columnNumber;
+}
+
+function positionToLocation(lineEndings: number[], position: number): number[] {
+  const lineNumber =
+      Platform.ArrayUtilities.upperBound(lineEndings, position - 1, Platform.ArrayUtilities.DEFAULT_COMPARATOR);
+  let columnNumber;
+  if (!lineNumber) {
+    columnNumber = position;
+  } else {
+    columnNumber = position - lineEndings[lineNumber - 1] - 1;
+  }
+  return [lineNumber, columnNumber];
+}
+
+export interface FormattedContent {
+  formattedContent: string;
+  formattedMapping: FormatterSourceMapping;
+}
+
+export async function format(
+    contentType: Common.ResourceType.ResourceType, mimeType: string, content: string,
+    indent: string =
+        Common.Settings.Settings.instance().moduleSetting('text-editor-indent').get()): Promise<FormattedContent> {
+  if (contentType.isDocumentOrScriptOrStyleSheet()) {
+    return await formatScriptContent(mimeType, content, indent);
+  }
+
+  return {formattedContent: content, formattedMapping: new IdentityFormatterSourceMapping()};
+}
+
+export async function formatScriptContent(
+    mimeType: string, content: string,
+    indent: string =
+        Common.Settings.Settings.instance().moduleSetting('text-editor-indent').get()): Promise<FormattedContent> {
+  const originalContent = content.replace(/\r\n?|[\n\u2028\u2029]/g, '\n').replace(/^\uFEFF/, '');
+
+  const pool = formatterWorkerPool();
+
+  let formatResult: FormatterActions.FormatResult = {content: originalContent, mapping: {original: [], formatted: []}};
+  try {
+    formatResult = await pool.format(mimeType, originalContent, indent);
+  } catch {
+  }
+  const originalContentLineEndings = Platform.StringUtilities.findLineEndingIndexes(originalContent);
+  const formattedContentLineEndings = Platform.StringUtilities.findLineEndingIndexes(formatResult.content);
+
+  const sourceMapping =
+      new FormatterSourceMappingImpl(originalContentLineEndings, formattedContentLineEndings, formatResult.mapping);
+  return {formattedContent: formatResult.content, formattedMapping: sourceMapping};
+}
+
+export interface FormatterSourceMapping {
+  originalToFormatted(lineNumber: number, columnNumber?: number): number[];
+  formattedToOriginal(lineNumber: number, columnNumber?: number): number[];
+}
+
+class IdentityFormatterSourceMapping implements FormatterSourceMapping {
+  originalToFormatted(lineNumber: number, columnNumber = 0): number[] {
+    return [lineNumber, columnNumber];
+  }
+
+  formattedToOriginal(lineNumber: number, columnNumber = 0): number[] {
+    return [lineNumber, columnNumber];
+  }
+}
+
+class FormatterSourceMappingImpl implements FormatterSourceMapping {
+  private readonly originalLineEndings: number[];
+  private readonly formattedLineEndings: number[];
+  private readonly mapping: FormatterActions.FormatMapping;
+
+  constructor(originalLineEndings: number[], formattedLineEndings: number[], mapping: FormatterActions.FormatMapping) {
+    this.originalLineEndings = originalLineEndings;
+    this.formattedLineEndings = formattedLineEndings;
+    this.mapping = mapping;
+  }
+
+  originalToFormatted(lineNumber: number, columnNumber?: number): number[] {
+    const originalPosition = locationToPosition(this.originalLineEndings, lineNumber, columnNumber || 0);
+    const formattedPosition = this.convertPosition(this.mapping.original, this.mapping.formatted, originalPosition);
+    return positionToLocation(this.formattedLineEndings, formattedPosition);
+  }
+
+  formattedToOriginal(lineNumber: number, columnNumber?: number): number[] {
+    const formattedPosition = locationToPosition(this.formattedLineEndings, lineNumber, columnNumber || 0);
+    const originalPosition = this.convertPosition(this.mapping.formatted, this.mapping.original, formattedPosition);
+    return positionToLocation(this.originalLineEndings, originalPosition);
+  }
+
+  private convertPosition(positions1: number[], positions2: number[], position: number): number {
+    const index =
+        Platform.ArrayUtilities.upperBound(positions1, position, Platform.ArrayUtilities.DEFAULT_COMPARATOR) - 1;
+    let convertedPosition: number = positions2[index] + position - positions1[index];
+    if (index < positions2.length - 1 && convertedPosition > positions2[index + 1]) {
+      convertedPosition = positions2[index + 1];
+    }
+    return convertedPosition;
+  }
+}

package/lib/front_end/models/formatter/formatter.ts

@@ -0,0 +1,8 @@
+// Copyright 2019 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 FormatterWorkerPool from './FormatterWorkerPool.js';
+import * as ScriptFormatter from './ScriptFormatter.js';
+
+export {FormatterWorkerPool, ScriptFormatter};

package/lib/front_end/models/text_utils/CodeMirrorUtils.ts

@@ -0,0 +1,37 @@
+// Copyright 2022 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 CodeMirror from '../../third_party/codemirror.next/codemirror.next.js';
+
+type Tokenizer = (line: string, callback: (value: string, style: string|null) => void) => Promise<void>;
+
+export function createCssTokenizer(): Tokenizer {
+  async function tokenize(line: string, callback: (value: string, style: string|null) => void): Promise<void> {
+    const streamParser = await CodeMirror.cssStreamParser();
+    const stream = new CodeMirror.StringStream(line, 4, 2);
+
+    const state = streamParser.startState(2);
+    let lastPos = stream.pos;
+    while (!stream.eol()) {
+      stream.start = lastPos;
+      let tokenType = streamParser.token(stream, state);
+      /**
+       * We expect unknown properties (like `unknownProp: unknownPropVal`) to still be
+       * formatted correctly. However, `tokenType` for such properties are marked
+       * as `error` from CodeMirror side and the internal state of the parser becomes `maybeprop`.
+       *
+       * So, we handle that specific keyword to be marked as `property` even though it is
+       * not a known property. We do this because for our formatting purposes it doesn't matter
+       * whether a property is a known CSS property or not.
+       */
+      if (tokenType === 'error' && state.state === 'maybeprop') {
+        tokenType = 'property';
+      }
+      const segment = stream.current();
+      callback(segment, tokenType);
+      lastPos = stream.pos;
+    }
+  }
+  return tokenize;
+}

package/lib/front_end/models/text_utils/ContentData.ts

@@ -0,0 +1,199 @@
+// Copyright 2023 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 Platform from '../../core/platform/platform.js';
+
+import { contentAsDataURL, type DeferredContent } from './ContentProvider.js';
+import {Text} from './Text.js';
+
+/**
+ * This class is a small wrapper around either raw binary or text data.
+ * As the binary data can actually contain textual data, we also store the
+ * MIME type and if applicable, the charset.
+ *
+ * This information should be generally kept together, as interpreting text
+ * from raw bytes requires an encoding.
+ *
+ * Note that we only rarely have to decode text ourselves in the frontend,
+ * this is mostly handled by the backend. There are cases though (e.g. SVG,
+ * or streaming response content) where we receive text data in
+ * binary (base64-encoded) form.
+ *
+ * The class only implements decoding. We currently don't have a use-case
+ * to re-encode text into base64 bytes using a specified charset.
+ */
+export class ContentData {
+  readonly mimeType: string;
+  readonly charset: string;
+
+  #contentAsBase64?: string;
+  #contentAsText?: string;
+
+  #contentAsTextObj?: Text;
+
+  constructor(data: string, isBase64: boolean, mimeType: string, charset?: string) {
+    this.charset = charset || 'utf-8';
+    if (isBase64) {
+      this.#contentAsBase64 = data;
+    } else {
+      this.#contentAsText = data;
+    }
+
+    this.mimeType = mimeType;
+    if (!this.mimeType) {
+      // Tests or broken requests might pass an empty/undefined mime type. Fallback to
+      // "default" mime types.
+      this.mimeType = isBase64 ? 'application/octet-stream' : 'text/plain';
+    }
+  }
+
+  /**
+   * Returns the data as base64.
+   *
+   * @throws if this `ContentData` was constructed from text content.
+   */
+  get base64(): string {
+    if (this.#contentAsBase64 === undefined) {
+      throw new Error('Encoding text content as base64 is not supported');
+    }
+    return this.#contentAsBase64;
+  }
+
+  /**
+   * Returns the content as text. If this `ContentData` was constructed with base64
+   * encoded bytes, it will use the provided charset to attempt to decode the bytes.
+   *
+   * @throws if `mimeType` is not a text type.
+   */
+  get text(): string {
+    if (this.#contentAsText !== undefined) {
+      return this.#contentAsText;
+    }
+
+    if (!this.isTextContent) {
+      throw new Error('Cannot interpret binary data as text');
+    }
+
+    const binaryString = window.atob(this.#contentAsBase64 as string);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+
+    this.#contentAsText = new TextDecoder(this.charset).decode(bytes);
+    return this.#contentAsText;
+  }
+
+  /** @returns true, if this `ContentData` was constructed from text content or the mime type indicates text that can be decoded */
+  get isTextContent(): boolean {
+    return this.#createdFromText || Platform.MimeType.isTextType(this.mimeType);
+  }
+
+  get isEmpty(): boolean {
+    // Don't trigger unnecessary decoding. Only check if both of the strings are empty.
+    return !Boolean(this.#contentAsBase64) && !Boolean(this.#contentAsText);
+  }
+
+  get createdFromBase64(): boolean {
+    return this.#contentAsBase64 !== undefined;
+  }
+
+  get #createdFromText(): boolean {
+    return this.#contentAsBase64 === undefined;
+  }
+
+  /**
+   * Returns the text content as a `Text` object. The returned object is always the same to
+   * minimize the number of times we have to calculate the line endings array.
+   *
+   * @throws if `mimeType` is not a text type.
+   */
+  get textObj(): Text {
+    if (this.#contentAsTextObj === undefined) {
+      this.#contentAsTextObj = new Text(this.text);
+    }
+    return this.#contentAsTextObj;
+  }
+
+  /**
+   * @returns True, iff the contents (base64 or text) are equal.
+   * Does not compare mime type and charset, but will decode base64 data if both
+   * mime types indicate that it's text content.
+   */
+  contentEqualTo(other: ContentData): boolean {
+    if (this.#contentAsBase64 !== undefined && other.#contentAsBase64 !== undefined) {
+      return this.#contentAsBase64 === other.#contentAsBase64;
+    }
+    if (this.#contentAsText !== undefined && other.#contentAsText !== undefined) {
+      return this.#contentAsText === other.#contentAsText;
+    }
+    if (this.isTextContent && other.isTextContent) {
+      return this.text === other.text;
+    }
+    return false;
+  }
+
+  asDataUrl(): string|null {
+    // To keep with existing behavior we prefer to return the content
+    // encoded if that is how this ContentData was constructed with.
+    if (this.#contentAsBase64 !== undefined) {
+      const charset = this.isTextContent ? this.charset : null;
+      return contentAsDataURL(this.#contentAsBase64, this.mimeType ?? '', true, charset);
+    }
+    return contentAsDataURL(this.text, this.mimeType ?? '', false, 'utf-8');
+  }
+
+  /**
+   * @deprecated Used during migration from `DeferredContent` to `ContentData`.
+   */
+  asDeferedContent(): DeferredContent {
+    // To prevent encoding mistakes, we'll return text content already decoded.
+    if (this.isTextContent) {
+      return {content: this.text, isEncoded: false};
+    }
+    if (this.#contentAsText !== undefined) {
+      // Unknown text mime type, this should not really happen.
+      return {content: this.#contentAsText, isEncoded: false};
+    }
+    if (this.#contentAsBase64 !== undefined) {
+      return {content: this.#contentAsBase64, isEncoded: true};
+    }
+    throw new Error('Unreachable');
+  }
+
+  static isError(contentDataOrError: ContentDataOrError): contentDataOrError is {error: string} {
+    return 'error' in contentDataOrError;
+  }
+
+  /** @returns `value` if the passed `ContentDataOrError` is an error, or the text content otherwise */
+  static textOr<T>(contentDataOrError: ContentDataOrError, value: T): string|T {
+    if (ContentData.isError(contentDataOrError)) {
+      return value;
+    }
+    return contentDataOrError.text;
+  }
+
+  /** @returns an empty 'text/plain' content data if the passed `ContentDataOrError` is an error, or the content data itself otherwise */
+  static contentDataOrEmpty(contentDataOrError: ContentDataOrError): ContentData {
+    if (ContentData.isError(contentDataOrError)) {
+      return EMPTY_TEXT_CONTENT_DATA;
+    }
+    return contentDataOrError;
+  }
+
+  /**
+   * @deprecated Used during migration from `DeferredContent` to `ContentData`.
+   */
+  static asDeferredContent(contentDataOrError: ContentDataOrError): DeferredContent {
+    if (ContentData.isError(contentDataOrError)) {
+      return {error: contentDataOrError.error, content: null, isEncoded: false};
+    }
+    return contentDataOrError.asDeferedContent();
+  }
+}
+
+export const EMPTY_TEXT_CONTENT_DATA = new ContentData('', /* isBase64 */ false, 'text/plain');
+
+export type ContentDataOrError = ContentData|{error: string};

package/lib/front_end/models/text_utils/ContentProvider.ts

@@ -0,0 +1,68 @@
+// Copyright 2012 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import type * as Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
+
+import type {ContentDataOrError} from './ContentData.js';
+import type {StreamingContentDataOrError} from './StreamingContentData.js';
+import type {WasmDisassembly} from './WasmDisassembly.js';
+
+export interface ContentProvider {
+  contentURL(): Platform.DevToolsPath.UrlString;
+  contentType(): Common.ResourceType.ResourceType;
+  requestContentData(): Promise<ContentDataOrError>;
+  searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise<SearchMatch[]>;
+}
+
+export class SearchMatch {
+  constructor(
+      readonly lineNumber: number, readonly lineContent: string, readonly columnNumber: number,
+      readonly matchLength: number) {
+  }
+
+  static comparator(a: SearchMatch, b: SearchMatch): number {
+    return a.lineNumber - b.lineNumber || a.columnNumber - b.columnNumber;
+  }
+}
+
+export const contentAsDataURL = function(
+    content: string|null, mimeType: string, contentEncoded: boolean, charset?: string|null,
+    limitSize = true): string|null {
+  const maxDataUrlSize = 1024 * 1024;
+  if (content === undefined || content === null || (limitSize && content.length > maxDataUrlSize)) {
+    return null;
+  }
+
+  content = contentEncoded ? content : encodeURIComponent(content);
+  return 'data:' + mimeType + (charset ? ';charset=' + charset : '') + (contentEncoded ? ';base64' : '') + ',' +
+      content;
+};
+
+export type DeferredContent = {
+  content: string,
+  isEncoded: boolean,
+}|{
+  content: '',
+  isEncoded: false,
+  wasmDisassemblyInfo: WasmDisassembly,
+}|{
+  content: null,
+  error: string,
+  isEncoded: boolean,
+};
+
+/**
+ * Some ContentProvider like NetworkRequests might never actually be able to return
+ * a fully completed "requestContentData" as the request keeps on going indefinitely.
+ * Such proivders can implement the "StreamingContentProvider" addition, which allows
+ * for partial/streaming content.
+ **/
+export interface StreamingContentProvider extends ContentProvider {
+  requestStreamingContent(): Promise<StreamingContentDataOrError>;
+}
+
+export const isStreamingContentProvider = function(provider: ContentProvider): provider is StreamingContentProvider {
+  return 'requestStreamingContent' in provider;
+};

package/lib/front_end/models/text_utils/StaticContentProvider.ts

@@ -0,0 +1,49 @@
+// Copyright 2014 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import type * as Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
+
+import {ContentData, type ContentDataOrError} from './ContentData.js';
+import type {ContentProvider, SearchMatch} from './ContentProvider.js';
+import {performSearchInContentData} from './TextUtils.js';
+
+export class StaticContentProvider implements ContentProvider {
+  readonly #contentURL: Platform.DevToolsPath.UrlString;
+  readonly #contentType: Common.ResourceType.ResourceType;
+  readonly #lazyContent: () => Promise<ContentDataOrError>;
+
+  constructor(
+      contentURL: Platform.DevToolsPath.UrlString, contentType: Common.ResourceType.ResourceType,
+      lazyContent: () => Promise<ContentDataOrError>) {
+    this.#contentURL = contentURL;
+    this.#contentType = contentType;
+    this.#lazyContent = lazyContent;
+  }
+
+  static fromString(
+      contentURL: Platform.DevToolsPath.UrlString, contentType: Common.ResourceType.ResourceType,
+      content: string): StaticContentProvider {
+    const lazyContent = (): Promise<ContentData> =>
+        Promise.resolve(new ContentData(content, /* isBase64 */ false, contentType.canonicalMimeType()));
+    return new StaticContentProvider(contentURL, contentType, lazyContent);
+  }
+
+  contentURL(): Platform.DevToolsPath.UrlString {
+    return this.#contentURL;
+  }
+
+  contentType(): Common.ResourceType.ResourceType {
+    return this.#contentType;
+  }
+
+  requestContentData(): Promise<ContentDataOrError> {
+    return this.#lazyContent();
+  }
+
+  async searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise<SearchMatch[]> {
+    const contentData = await this.requestContentData();
+    return performSearchInContentData(contentData, query, caseSensitive, isRegex);
+  }
+}