devtools-tracing 1.0.1 → 1.1.1

package/lib/front_end/models/bindings/SASSSourceMapping.ts

@@ -0,0 +1,222 @@
+// 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 * as Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
+import * as SDK from '../../core/sdk/sdk.js';
+import type * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+import * as Workspace from '../workspace/workspace.js';
+
+import {ContentProviderBasedProject} from './ContentProviderBasedProject.js';
+import {CSSWorkspaceBinding, type SourceMapping} from './CSSWorkspaceBinding.js';
+import {NetworkProject} from './NetworkProject.js';
+
+export class SASSSourceMapping implements SourceMapping {
+  readonly #sourceMapManager: SDK.SourceMapManager.SourceMapManager<SDK.CSSStyleSheetHeader.CSSStyleSheetHeader>;
+  readonly #project: ContentProviderBasedProject;
+  readonly #eventListeners: Common.EventTarget.EventDescriptor[];
+  readonly #bindings: Map<string, Binding>;
+
+  constructor(
+      target: SDK.Target.Target,
+      sourceMapManager: SDK.SourceMapManager.SourceMapManager<SDK.CSSStyleSheetHeader.CSSStyleSheetHeader>,
+      workspace: Workspace.Workspace.WorkspaceImpl) {
+    this.#sourceMapManager = sourceMapManager;
+    this.#project = new ContentProviderBasedProject(
+        workspace, 'cssSourceMaps:' + target.id(), Workspace.Workspace.projectTypes.Network, '',
+        false /* isServiceProject */);
+    NetworkProject.setTargetForProject(this.#project, target);
+
+    this.#bindings = new Map();
+
+    this.#eventListeners = [
+      this.#sourceMapManager.addEventListener(
+          SDK.SourceMapManager.Events.SourceMapAttached, this.sourceMapAttached, this),
+      this.#sourceMapManager.addEventListener(
+          SDK.SourceMapManager.Events.SourceMapDetached, this.sourceMapDetached, this),
+    ];
+  }
+
+  private sourceMapAttachedForTest(_sourceMap: SDK.SourceMap.SourceMap|null): void {
+  }
+
+  private async sourceMapAttached(
+      event: Common.EventTarget
+          .EventTargetEvent<{client: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader, sourceMap: SDK.SourceMap.SourceMap}>):
+      Promise<void> {
+    const header = event.data.client;
+    const sourceMap = event.data.sourceMap;
+    const project = this.#project;
+    const bindings = this.#bindings;
+    for (const sourceURL of sourceMap.sourceURLs()) {
+      let binding = bindings.get(sourceURL);
+      if (!binding) {
+        binding = new Binding(project, sourceURL, header.createPageResourceLoadInitiator());
+        bindings.set(sourceURL, binding);
+      }
+      binding.addSourceMap(sourceMap, header.frameId);
+    }
+    await CSSWorkspaceBinding.instance().updateLocations(header);
+    this.sourceMapAttachedForTest(sourceMap);
+  }
+
+  private async sourceMapDetached(
+      event: Common.EventTarget
+          .EventTargetEvent<{client: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader, sourceMap: SDK.SourceMap.SourceMap}>):
+      Promise<void> {
+    const header = event.data.client;
+    const sourceMap = event.data.sourceMap;
+    const bindings = this.#bindings;
+    for (const sourceURL of sourceMap.sourceURLs()) {
+      const binding = bindings.get(sourceURL);
+      if (binding) {
+        binding.removeSourceMap(sourceMap, header.frameId);
+        if (!binding.getUiSourceCode()) {
+          bindings.delete(sourceURL);
+        }
+      }
+    }
+    await CSSWorkspaceBinding.instance().updateLocations(header);
+  }
+
+  rawLocationToUILocation(rawLocation: SDK.CSSModel.CSSLocation): Workspace.UISourceCode.UILocation|null {
+    const header = rawLocation.header();
+    if (!header) {
+      return null;
+    }
+    const sourceMap = this.#sourceMapManager.sourceMapForClient(header);
+    if (!sourceMap) {
+      return null;
+    }
+    let {lineNumber, columnNumber} = rawLocation;
+    // If the source map maps the origin (line:0, column:0) but the CSS header is inline (in a HTML doc),
+    // then adjust the line and column numbers.
+    if (sourceMap.mapsOrigin() && header.isInline) {
+      lineNumber -= header.startLine;
+      if (lineNumber === 0) {
+        columnNumber -= header.startColumn;
+      }
+    }
+    const entry = sourceMap.findEntry(lineNumber, columnNumber);
+    if (!entry?.sourceURL) {
+      return null;
+    }
+    const uiSourceCode = this.#project.uiSourceCodeForURL(entry.sourceURL);
+    if (!uiSourceCode) {
+      return null;
+    }
+    return uiSourceCode.uiLocation(entry.sourceLineNumber, entry.sourceColumnNumber);
+  }
+
+  uiLocationToRawLocations(uiLocation: Workspace.UISourceCode.UILocation): SDK.CSSModel.CSSLocation[] {
+    // TODO(crbug.com/1153123): Revisit the `#columnNumber || 0` and also preserve `undefined` for source maps?
+    const {uiSourceCode, lineNumber, columnNumber = 0} = uiLocation;
+    const binding = uiSourceCodeToBinding.get(uiSourceCode);
+    if (!binding) {
+      return [];
+    }
+    const locations: SDK.CSSModel.CSSLocation[] = [];
+    for (const sourceMap of binding.getReferringSourceMaps()) {
+      const entries = sourceMap.findReverseEntries(uiSourceCode.url(), lineNumber, columnNumber);
+      const header = this.#sourceMapManager.clientForSourceMap(sourceMap);
+      if (header) {
+        locations.push(
+            ...entries.map(entry => new SDK.CSSModel.CSSLocation(header, entry.lineNumber, entry.columnNumber)));
+      }
+    }
+    return locations;
+  }
+
+  static uiSourceOrigin(uiSourceCode: Workspace.UISourceCode.UISourceCode): Platform.DevToolsPath.UrlString[] {
+    const binding = uiSourceCodeToBinding.get(uiSourceCode);
+    if (binding) {
+      return binding.getReferringSourceMaps().map(sourceMap => sourceMap.compiledURL());
+    }
+    return [];
+  }
+
+  dispose(): void {
+    Common.EventTarget.removeEventListeners(this.#eventListeners);
+    this.#project.dispose();
+  }
+}
+
+const uiSourceCodeToBinding = new WeakMap<Workspace.UISourceCode.UISourceCode, Binding>();
+
+class Binding {
+  readonly #project: ContentProviderBasedProject;
+  readonly #url: Platform.DevToolsPath.UrlString;
+  readonly #initiator: SDK.PageResourceLoader.PageResourceLoadInitiator;
+  referringSourceMaps: SDK.SourceMap.SourceMap[];
+  uiSourceCode: Workspace.UISourceCode.UISourceCode|null;
+
+  constructor(
+      project: ContentProviderBasedProject, url: Platform.DevToolsPath.UrlString,
+      initiator: SDK.PageResourceLoader.PageResourceLoadInitiator) {
+    this.#project = project;
+    this.#url = url;
+    this.#initiator = initiator;
+
+    this.referringSourceMaps = [];
+    this.uiSourceCode = null;
+  }
+
+  private recreateUISourceCodeIfNeeded(frameId: Protocol.Page.FrameId): void {
+    const sourceMap = this.referringSourceMaps[this.referringSourceMaps.length - 1];
+
+    const contentType = Common.ResourceType.resourceTypes.SourceMapStyleSheet;
+    const embeddedContent = sourceMap.embeddedContentByURL(this.#url);
+    const contentProvider = embeddedContent !== null ?
+        TextUtils.StaticContentProvider.StaticContentProvider.fromString(this.#url, contentType, embeddedContent) :
+        new SDK.CompilerSourceMappingContentProvider.CompilerSourceMappingContentProvider(
+            this.#url, contentType, this.#initiator);
+    const newUISourceCode = this.#project.createUISourceCode(this.#url, contentType);
+    uiSourceCodeToBinding.set(newUISourceCode, this);
+    const mimeType = Common.ResourceType.ResourceType.mimeFromURL(this.#url) || contentType.canonicalMimeType();
+    const metadata = typeof embeddedContent === 'string' ?
+        new Workspace.UISourceCode.UISourceCodeMetadata(null, embeddedContent.length) :
+        null;
+
+    if (this.uiSourceCode) {
+      NetworkProject.cloneInitialFrameAttribution(this.uiSourceCode, newUISourceCode);
+      this.#project.removeUISourceCode(this.uiSourceCode.url());
+    } else {
+      NetworkProject.setInitialFrameAttribution(newUISourceCode, frameId);
+    }
+    this.uiSourceCode = newUISourceCode;
+    this.#project.addUISourceCodeWithProvider(this.uiSourceCode, contentProvider, metadata, mimeType);
+  }
+
+  addSourceMap(sourceMap: SDK.SourceMap.SourceMap, frameId: Protocol.Page.FrameId): void {
+    if (this.uiSourceCode) {
+      NetworkProject.addFrameAttribution(this.uiSourceCode, frameId);
+    }
+    this.referringSourceMaps.push(sourceMap);
+    this.recreateUISourceCodeIfNeeded(frameId);
+  }
+
+  removeSourceMap(sourceMap: SDK.SourceMap.SourceMap, frameId: Protocol.Page.FrameId): void {
+    const uiSourceCode = (this.uiSourceCode as Workspace.UISourceCode.UISourceCode);
+    NetworkProject.removeFrameAttribution(uiSourceCode, frameId);
+    const lastIndex = this.referringSourceMaps.lastIndexOf(sourceMap);
+    if (lastIndex !== -1) {
+      this.referringSourceMaps.splice(lastIndex, 1);
+    }
+    if (!this.referringSourceMaps.length) {
+      this.#project.removeUISourceCode(uiSourceCode.url());
+      this.uiSourceCode = null;
+    } else {
+      this.recreateUISourceCodeIfNeeded(frameId);
+    }
+  }
+
+  getReferringSourceMaps(): SDK.SourceMap.SourceMap[] {
+    return this.referringSourceMaps;
+  }
+
+  getUiSourceCode(): Workspace.UISourceCode.UISourceCode|null {
+    return this.uiSourceCode;
+  }
+}

package/lib/front_end/models/bindings/StylesSourceMapping.ts

@@ -0,0 +1,316 @@
+// 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 * as Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
+import * as SDK from '../../core/sdk/sdk.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+import * as Workspace from '../workspace/workspace.js';
+
+import {ContentProviderBasedProject} from './ContentProviderBasedProject.js';
+import type {SourceMapping} from './CSSWorkspaceBinding.js';
+import {NetworkProject} from './NetworkProject.js';
+import {metadataForURL} from './ResourceUtils.js';
+
+const uiSourceCodeToStyleMap = new WeakMap<Workspace.UISourceCode.UISourceCode, StyleFile>();
+
+export class StylesSourceMapping implements SourceMapping {
+  #cssModel: SDK.CSSModel.CSSModel;
+  #project: ContentProviderBasedProject;
+  readonly #styleFiles = new Map<string, StyleFile>();
+  readonly #eventListeners: Common.EventTarget.EventDescriptor[];
+
+  constructor(cssModel: SDK.CSSModel.CSSModel, workspace: Workspace.Workspace.WorkspaceImpl) {
+    this.#cssModel = cssModel;
+    const target = this.#cssModel.target();
+    this.#project = new ContentProviderBasedProject(
+        workspace, 'css:' + target.id(), Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
+    NetworkProject.setTargetForProject(this.#project, target);
+
+    this.#eventListeners = [
+      this.#cssModel.addEventListener(SDK.CSSModel.Events.StyleSheetAdded, this.styleSheetAdded, this),
+      this.#cssModel.addEventListener(SDK.CSSModel.Events.StyleSheetRemoved, this.styleSheetRemoved, this),
+      this.#cssModel.addEventListener(SDK.CSSModel.Events.StyleSheetChanged, this.styleSheetChanged, this),
+    ];
+  }
+
+  addSourceMap(sourceUrl: Platform.DevToolsPath.UrlString, sourceMapUrl: Platform.DevToolsPath.UrlString): void {
+    this.#styleFiles.get(sourceUrl)?.addSourceMap(sourceUrl, sourceMapUrl);
+  }
+
+  rawLocationToUILocation(rawLocation: SDK.CSSModel.CSSLocation): Workspace.UISourceCode.UILocation|null {
+    const header = rawLocation.header();
+    if (!header || !this.acceptsHeader(header)) {
+      return null;
+    }
+    const styleFile = this.#styleFiles.get(header.resourceURL());
+    if (!styleFile) {
+      return null;
+    }
+    let lineNumber = rawLocation.lineNumber;
+    let columnNumber: undefined|number = rawLocation.columnNumber;
+    if (header.isInline && header.hasSourceURL) {
+      lineNumber -= header.lineNumberInSource(0);
+      const headerColumnNumber = header.columnNumberInSource(lineNumber, 0);
+      if (typeof headerColumnNumber === 'undefined') {
+        columnNumber = headerColumnNumber;
+      } else {
+        columnNumber -= headerColumnNumber;
+      }
+    }
+    return styleFile.getUiSourceCode().uiLocation(lineNumber, columnNumber);
+  }
+
+  uiLocationToRawLocations(uiLocation: Workspace.UISourceCode.UILocation): SDK.CSSModel.CSSLocation[] {
+    const styleFile = uiSourceCodeToStyleMap.get(uiLocation.uiSourceCode);
+    if (!styleFile) {
+      return [];
+    }
+    const rawLocations = [];
+    for (const header of styleFile.getHeaders()) {
+      let lineNumber = uiLocation.lineNumber;
+      let columnNumber = uiLocation.columnNumber;
+      if (header.isInline && header.hasSourceURL) {
+        // TODO(crbug.com/1153123): Revisit the `#columnNumber || 0` and also preserve `undefined` for source maps?
+        columnNumber = header.columnNumberInSource(lineNumber, uiLocation.columnNumber || 0);
+        lineNumber = header.lineNumberInSource(lineNumber);
+      }
+      rawLocations.push(new SDK.CSSModel.CSSLocation(header, lineNumber, columnNumber));
+    }
+    return rawLocations;
+  }
+
+  private acceptsHeader(header: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader): boolean {
+    if (header.isConstructedByNew()) {
+      return false;
+    }
+    if (header.isInline && !header.hasSourceURL && header.origin !== 'inspector') {
+      return false;
+    }
+    if (!header.resourceURL()) {
+      return false;
+    }
+    return true;
+  }
+
+  private styleSheetAdded(event: Common.EventTarget.EventTargetEvent<SDK.CSSStyleSheetHeader.CSSStyleSheetHeader>):
+      void {
+    const header = event.data;
+    if (!this.acceptsHeader(header)) {
+      return;
+    }
+
+    const url = header.resourceURL();
+    let styleFile = this.#styleFiles.get(url);
+    if (!styleFile) {
+      styleFile = new StyleFile(this.#cssModel, this.#project, header);
+      this.#styleFiles.set(url, styleFile);
+    } else {
+      styleFile.addHeader(header);
+    }
+  }
+
+  private styleSheetRemoved(event: Common.EventTarget.EventTargetEvent<SDK.CSSStyleSheetHeader.CSSStyleSheetHeader>):
+      void {
+    const header = event.data;
+    if (!this.acceptsHeader(header)) {
+      return;
+    }
+    const url = header.resourceURL();
+    const styleFile = this.#styleFiles.get(url);
+    if (styleFile) {
+      if (styleFile.getHeaders().size === 1) {
+        styleFile.dispose();
+        this.#styleFiles.delete(url);
+      } else {
+        styleFile.removeHeader(header);
+      }
+    }
+  }
+
+  private styleSheetChanged(event: Common.EventTarget.EventTargetEvent<SDK.CSSModel.StyleSheetChangedEvent>): void {
+    const header = this.#cssModel.styleSheetHeaderForId(event.data.styleSheetId);
+    if (!header || !this.acceptsHeader(header)) {
+      return;
+    }
+    const styleFile = this.#styleFiles.get(header.resourceURL());
+    if (styleFile) {
+      styleFile.styleSheetChanged(header);
+    }
+  }
+
+  dispose(): void {
+    for (const styleFile of this.#styleFiles.values()) {
+      styleFile.dispose();
+    }
+    this.#styleFiles.clear();
+    Common.EventTarget.removeEventListeners(this.#eventListeners);
+    this.#project.removeProject();
+  }
+}
+
+export class StyleFile implements TextUtils.ContentProvider.ContentProvider {
+  readonly #cssModel: SDK.CSSModel.CSSModel;
+  readonly #project: ContentProviderBasedProject;
+  headers: Set<SDK.CSSStyleSheetHeader.CSSStyleSheetHeader>;
+  uiSourceCode: Workspace.UISourceCode.UISourceCode;
+  readonly #eventListeners: Common.EventTarget.EventDescriptor[];
+  readonly #throttler = new Common.Throttler.Throttler(200);
+  #terminated = false;
+  #isAddingRevision?: boolean;
+  #isUpdatingHeaders?: boolean;
+
+  constructor(
+      cssModel: SDK.CSSModel.CSSModel, project: ContentProviderBasedProject,
+      header: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader) {
+    this.#cssModel = cssModel;
+    this.#project = project;
+    this.headers = new Set([header]);
+
+    const target = cssModel.target();
+
+    const url = header.resourceURL();
+    const metadata = metadataForURL(target, header.frameId, url);
+
+    this.uiSourceCode = this.#project.createUISourceCode(url, header.contentType());
+    uiSourceCodeToStyleMap.set(this.uiSourceCode, this);
+    NetworkProject.setInitialFrameAttribution(this.uiSourceCode, header.frameId);
+    this.#project.addUISourceCodeWithProvider(this.uiSourceCode, this, metadata, 'text/css');
+
+    this.#eventListeners = [
+      this.uiSourceCode.addEventListener(
+          Workspace.UISourceCode.Events.WorkingCopyChanged, this.workingCopyChanged, this),
+      this.uiSourceCode.addEventListener(
+          Workspace.UISourceCode.Events.WorkingCopyCommitted, this.workingCopyCommitted, this),
+    ];
+  }
+
+  addHeader(header: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader): void {
+    this.headers.add(header);
+    NetworkProject.addFrameAttribution(this.uiSourceCode, header.frameId);
+  }
+
+  removeHeader(header: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader): void {
+    this.headers.delete(header);
+    NetworkProject.removeFrameAttribution(this.uiSourceCode, header.frameId);
+  }
+
+  styleSheetChanged(header: SDK.CSSStyleSheetHeader.CSSStyleSheetHeader): void {
+    console.assert(this.headers.has(header));
+    if (this.#isUpdatingHeaders || !this.headers.has(header)) {
+      return;
+    }
+    const mirrorContentBound = this.mirrorContent.bind(this, header, true /* majorChange */);
+    void this.#throttler.schedule(mirrorContentBound, Common.Throttler.Scheduling.DEFAULT);
+  }
+
+  private workingCopyCommitted(): void {
+    if (this.#isAddingRevision) {
+      return;
+    }
+    const mirrorContentBound = this.mirrorContent.bind(this, this.uiSourceCode, true /* majorChange */);
+    void this.#throttler.schedule(mirrorContentBound, Common.Throttler.Scheduling.AS_SOON_AS_POSSIBLE);
+  }
+
+  private workingCopyChanged(): void {
+    if (this.#isAddingRevision) {
+      return;
+    }
+    const mirrorContentBound = this.mirrorContent.bind(this, this.uiSourceCode, false /* majorChange */);
+    void this.#throttler.schedule(mirrorContentBound, Common.Throttler.Scheduling.DEFAULT);
+  }
+
+  private async mirrorContent(fromProvider: TextUtils.ContentProvider.ContentProvider, majorChange: boolean):
+      Promise<void> {
+    if (this.#terminated) {
+      this.styleFileSyncedForTest();
+      return;
+    }
+
+    let newContent: string|null = null;
+    if (fromProvider === this.uiSourceCode) {
+      newContent = this.uiSourceCode.workingCopy();
+    } else {
+      newContent = TextUtils.ContentData.ContentData.textOr(await fromProvider.requestContentData(), null);
+    }
+
+    if (newContent === null || this.#terminated) {
+      this.styleFileSyncedForTest();
+      return;
+    }
+
+    if (fromProvider !== this.uiSourceCode) {
+      this.#isAddingRevision = true;
+      this.uiSourceCode.setWorkingCopy(newContent);
+      this.#isAddingRevision = false;
+    }
+
+    this.#isUpdatingHeaders = true;
+    const promises = [];
+    for (const header of this.headers) {
+      if (header === fromProvider) {
+        continue;
+      }
+      promises.push(this.#cssModel.setStyleSheetText(header.id, newContent, majorChange));
+    }
+    // ------ ASYNC ------
+    await Promise.all(promises);
+    this.#isUpdatingHeaders = false;
+    this.styleFileSyncedForTest();
+  }
+
+  private styleFileSyncedForTest(): void {
+  }
+
+  dispose(): void {
+    if (this.#terminated) {
+      return;
+    }
+    this.#terminated = true;
+    this.#project.removeUISourceCode(this.uiSourceCode.url());
+    Common.EventTarget.removeEventListeners(this.#eventListeners);
+  }
+
+  contentURL(): Platform.DevToolsPath.UrlString {
+    console.assert(this.headers.size > 0);
+    return this.#firstHeader().originalContentProvider().contentURL();
+  }
+
+  contentType(): Common.ResourceType.ResourceType {
+    console.assert(this.headers.size > 0);
+    return this.#firstHeader().originalContentProvider().contentType();
+  }
+
+  requestContentData(): Promise<TextUtils.ContentData.ContentDataOrError> {
+    console.assert(this.headers.size > 0);
+    return this.#firstHeader().originalContentProvider().requestContentData();
+  }
+
+  searchInContent(query: string, caseSensitive: boolean, isRegex: boolean):
+      Promise<TextUtils.ContentProvider.SearchMatch[]> {
+    console.assert(this.headers.size > 0);
+    return this.#firstHeader().originalContentProvider().searchInContent(query, caseSensitive, isRegex);
+  }
+
+  #firstHeader(): SDK.CSSStyleSheetHeader.CSSStyleSheetHeader {
+    console.assert(this.headers.size > 0);
+    return this.headers.values().next().value as SDK.CSSStyleSheetHeader.CSSStyleSheetHeader;
+  }
+
+  getHeaders(): Set<SDK.CSSStyleSheetHeader.CSSStyleSheetHeader> {
+    return this.headers;
+  }
+
+  getUiSourceCode(): Workspace.UISourceCode.UISourceCode {
+    return this.uiSourceCode;
+  }
+
+  addSourceMap(sourceUrl: Platform.DevToolsPath.UrlString, sourceMapUrl: Platform.DevToolsPath.UrlString): void {
+    const sourceMapManager = this.#cssModel.sourceMapManager();
+    this.headers.forEach(header => {
+      sourceMapManager.detachSourceMap(header);
+      sourceMapManager.attachSourceMap(header, sourceUrl, sourceMapUrl);
+    });
+  }
+}

package/lib/front_end/models/bindings/TempFile.ts

@@ -0,0 +1,67 @@
+// Copyright 2013 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 {ChunkedFileReader, type ChunkedReader} from './FileUtils.js';
+
+export class TempFile {
+  #lastBlob: Blob|null;
+  constructor() {
+    this.#lastBlob = null;
+  }
+
+  write(pieces: Array<string|Blob>): void {
+    if (this.#lastBlob) {
+      pieces.unshift(this.#lastBlob);
+    }
+    this.#lastBlob = new Blob(pieces, {type: 'text/plain'});
+  }
+
+  read(): Promise<string|null> {
+    return this.readRange();
+  }
+
+  size(): number {
+    return this.#lastBlob ? this.#lastBlob.size : 0;
+  }
+
+  async readRange(startOffset?: number, endOffset?: number): Promise<string|null> {
+    if (!this.#lastBlob) {
+      Common.Console.Console.instance().error('Attempt to read a temp file that was never written');
+      return '';
+    }
+    const blob = typeof startOffset === 'number' || typeof endOffset === 'number' ?
+        this.#lastBlob.slice((startOffset as number), (endOffset as number)) :
+        this.#lastBlob;
+
+    const reader = new FileReader();
+    try {
+      await new Promise((resolve, reject) => {
+        reader.onloadend = resolve;
+        reader.onerror = reject;
+        reader.readAsText(blob);
+      });
+    } catch (error) {
+      Common.Console.Console.instance().error('Failed to read from temp file: ' + error.message);
+    }
+
+    return reader.result as string | null;
+  }
+
+  async copyToOutputStream(
+      outputStream: Common.StringOutputStream.OutputStream,
+      progress?: ((arg0: ChunkedReader) => void)): Promise<DOMError|null> {
+    if (!this.#lastBlob) {
+      void outputStream.close();
+      return null;
+    }
+    const reader = new ChunkedFileReader((this.#lastBlob as File), 10 * 1000 * 1000, progress);
+    return await reader.read(outputStream).then(success => success ? null : reader.error());
+  }
+
+  remove(): void {
+    this.#lastBlob = null;
+  }
+}

package/lib/front_end/models/bindings/bindings.ts

@@ -0,0 +1,39 @@
+// 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 CompilerScriptMapping from './CompilerScriptMapping.js';
+import * as ContentProviderBasedProject from './ContentProviderBasedProject.js';
+import * as CSSWorkspaceBinding from './CSSWorkspaceBinding.js';
+import * as DebuggerLanguagePlugins from './DebuggerLanguagePlugins.js';
+import * as DebuggerWorkspaceBinding from './DebuggerWorkspaceBinding.js';
+import * as DefaultScriptMapping from './DefaultScriptMapping.js';
+import * as FileUtils from './FileUtils.js';
+import * as LiveLocation from './LiveLocation.js';
+import * as NetworkProject from './NetworkProject.js';
+import * as PresentationConsoleMessageHelper from './PresentationConsoleMessageHelper.js';
+import * as ResourceMapping from './ResourceMapping.js';
+import * as ResourceScriptMapping from './ResourceScriptMapping.js';
+import * as ResourceUtils from './ResourceUtils.js';
+import * as SASSSourceMapping from './SASSSourceMapping.js';
+import * as StylesSourceMapping from './StylesSourceMapping.js';
+import * as TempFile from './TempFile.js';
+
+export {
+  CompilerScriptMapping,
+  ContentProviderBasedProject,
+  CSSWorkspaceBinding,
+  DebuggerLanguagePlugins,
+  DebuggerWorkspaceBinding,
+  DefaultScriptMapping,
+  FileUtils,
+  LiveLocation,
+  NetworkProject,
+  PresentationConsoleMessageHelper,
+  ResourceMapping,
+  ResourceScriptMapping,
+  ResourceUtils,
+  SASSSourceMapping,
+  StylesSourceMapping,
+  TempFile,
+};