devtools-tracing 1.1.1 → 1.2.1

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

@@ -1,11 +0,0 @@
-// Copyright 2020 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 {PageResourceLoadInitiator} from './PageResourceLoader.js';
-import type {DebugId} from './SourceMap.js';
-
-export interface FrameAssociated {
-  createPageResourceLoadInitiator(): PageResourceLoadInitiator;
-  debugId(): DebugId|null;
-}

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

@@ -1,259 +0,0 @@
-// Copyright 2020 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 Protocol from '../../generated/protocol.js';
-import * as Common from '../common/common.js';
-
-import type {Resource} from './Resource.js';
-import {Events as ResourceTreeModelEvents, type ResourceTreeFrame, ResourceTreeModel} from './ResourceTreeModel.js';
-import type {Target} from './Target.js';
-import {type SDKModelObserver, TargetManager} from './TargetManager.js';
-
-let frameManagerInstance: FrameManager|null = null;
-
-/**
- * The FrameManager is a central storage for all #frames. It collects #frames from all
- * ResourceTreeModel-instances (one per target), so that #frames can be found by id
- * without needing to know their target.
- */
-export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
-    SDKModelObserver<ResourceTreeModel> {
-  readonly #eventListeners = new WeakMap<ResourceTreeModel, Common.EventTarget.EventDescriptor[]>();
-
-  // Maps frameIds to #frames and a count of how many ResourceTreeModels contain this frame.
-  // (OOPIFs are usually first attached to a new target and then detached from their old target,
-  // therefore being contained in 2 models for a short period of time.)
-  #frames = new Map<string, {
-    frame: ResourceTreeFrame,
-    count: number,
-  }>();
-
-  readonly #framesForTarget = new Map<Protocol.Target.TargetID|'main', Set<Protocol.Page.FrameId>>();
-  #outermostFrame: ResourceTreeFrame|null = null;
-  #transferringFramesDataCache = new Map<string, {
-    creationStackTrace?: Protocol.Runtime.StackTrace,
-    creationStackTraceTarget?: Target,
-  }>();
-  #awaitedFrames = new Map<string, Array<{resolve: (frame: ResourceTreeFrame) => void, notInTarget?: Target}>>();
-
-  constructor() {
-    super();
-    TargetManager.instance().observeModels(ResourceTreeModel, this);
-  }
-
-  static instance({forceNew}: {
-    forceNew: boolean,
-  } = {forceNew: false}): FrameManager {
-    if (!frameManagerInstance || forceNew) {
-      frameManagerInstance = new FrameManager();
-    }
-    return frameManagerInstance;
-  }
-
-  static removeInstance(): void {
-    frameManagerInstance = null;
-  }
-
-  modelAdded(resourceTreeModel: ResourceTreeModel): void {
-    const addListener = resourceTreeModel.addEventListener(ResourceTreeModelEvents.FrameAdded, this.frameAdded, this);
-    const detachListener =
-        resourceTreeModel.addEventListener(ResourceTreeModelEvents.FrameDetached, this.frameDetached, this);
-    const navigatedListener =
-        resourceTreeModel.addEventListener(ResourceTreeModelEvents.FrameNavigated, this.frameNavigated, this);
-    const resourceAddedListener =
-        resourceTreeModel.addEventListener(ResourceTreeModelEvents.ResourceAdded, this.resourceAdded, this);
-    this.#eventListeners.set(
-        resourceTreeModel, [addListener, detachListener, navigatedListener, resourceAddedListener]);
-    this.#framesForTarget.set(resourceTreeModel.target().id(), new Set());
-  }
-
-  modelRemoved(resourceTreeModel: ResourceTreeModel): void {
-    const listeners = this.#eventListeners.get(resourceTreeModel);
-    if (listeners) {
-      Common.EventTarget.removeEventListeners(listeners);
-    }
-
-    // Iterate over this model's #frames and decrease their count or remove them.
-    // (The ResourceTreeModel does not send FrameDetached events when a model
-    // is removed.)
-    const frameSet = this.#framesForTarget.get(resourceTreeModel.target().id());
-    if (frameSet) {
-      for (const frameId of frameSet) {
-        this.decreaseOrRemoveFrame(frameId);
-      }
-    }
-    this.#framesForTarget.delete(resourceTreeModel.target().id());
-  }
-
-  private frameAdded(event: Common.EventTarget.EventTargetEvent<ResourceTreeFrame>): void {
-    const frame = event.data;
-    const frameData = this.#frames.get(frame.id);
-    // If the frame is already in the map, increase its count, otherwise add it to the map.
-    if (frameData) {
-      // In order to not lose the following attributes of a frame during
-      // an OOPIF transfer we need to copy them to the new frame
-      frame.setCreationStackTrace(frameData.frame.getCreationStackTraceData());
-      this.#frames.set(frame.id, {frame, count: frameData.count + 1});
-    } else {
-      // If the transferring frame's detached event is received before its frame added
-      // event in the new target, the frame's cached attributes are reassigned.
-      const cachedFrameAttributes = this.#transferringFramesDataCache.get(frame.id);
-      if (cachedFrameAttributes?.creationStackTrace && cachedFrameAttributes?.creationStackTraceTarget) {
-        frame.setCreationStackTrace({
-          creationStackTrace: cachedFrameAttributes.creationStackTrace,
-          creationStackTraceTarget: cachedFrameAttributes.creationStackTraceTarget,
-        });
-      }
-      this.#frames.set(frame.id, {frame, count: 1});
-      this.#transferringFramesDataCache.delete(frame.id);
-    }
-    this.resetOutermostFrame();
-
-    // Add the frameId to the the targetId's set of frameIds.
-    const frameSet = this.#framesForTarget.get(frame.resourceTreeModel().target().id());
-    if (frameSet) {
-      frameSet.add(frame.id);
-    }
-
-    this.dispatchEventToListeners(Events.FRAME_ADDED_TO_TARGET, {frame});
-    this.resolveAwaitedFrame(frame);
-  }
-
-  private frameDetached(event: Common.EventTarget.EventTargetEvent<{frame: ResourceTreeFrame, isSwap: boolean}>): void {
-    const {frame, isSwap} = event.data;
-    // Decrease the frame's count or remove it entirely from the map.
-    this.decreaseOrRemoveFrame(frame.id);
-
-    // If the transferring frame's detached event is received before its frame
-    // added event in the new target, we persist some attributes of the frame here
-    // so that later on the frame added event in the new target they can be reassigned.
-    if (isSwap && !this.#frames.get(frame.id)) {
-      const traceData = frame.getCreationStackTraceData();
-      const cachedFrameAttributes = {
-        ...(traceData.creationStackTrace && {creationStackTrace: traceData.creationStackTrace}),
-        ...(traceData.creationStackTrace && {creationStackTraceTarget: traceData.creationStackTraceTarget}),
-      };
-      this.#transferringFramesDataCache.set(frame.id, cachedFrameAttributes);
-    }
-
-    // Remove the frameId from the target's set of frameIds.
-    const frameSet = this.#framesForTarget.get(frame.resourceTreeModel().target().id());
-    if (frameSet) {
-      frameSet.delete(frame.id);
-    }
-  }
-
-  private frameNavigated(event: Common.EventTarget.EventTargetEvent<ResourceTreeFrame>): void {
-    const frame = event.data;
-    this.dispatchEventToListeners(Events.FRAME_NAVIGATED, {frame});
-    if (frame.isOutermostFrame()) {
-      this.dispatchEventToListeners(Events.OUTERMOST_FRAME_NAVIGATED, {frame});
-    }
-  }
-
-  private resourceAdded(event: Common.EventTarget.EventTargetEvent<Resource>): void {
-    this.dispatchEventToListeners(Events.RESOURCE_ADDED, {resource: event.data});
-  }
-
-  private decreaseOrRemoveFrame(frameId: Protocol.Page.FrameId): void {
-    const frameData = this.#frames.get(frameId);
-    if (frameData) {
-      if (frameData.count === 1) {
-        this.#frames.delete(frameId);
-        this.resetOutermostFrame();
-        this.dispatchEventToListeners(Events.FRAME_REMOVED, {frameId});
-      } else {
-        frameData.count--;
-      }
-    }
-  }
-
-  /**
-   * Looks for the outermost frame in `#frames` and sets `#outermostFrame` accordingly.
-   *
-   * Important: This method needs to be called everytime `#frames` is updated.
-   */
-  private resetOutermostFrame(): void {
-    const outermostFrames = this.getAllFrames().filter(frame => frame.isOutermostFrame());
-    this.#outermostFrame = outermostFrames.length > 0 ? outermostFrames[0] : null;
-  }
-
-  /**
-   * Returns the ResourceTreeFrame with a given frameId.
-   * When a frame is being detached a new ResourceTreeFrame but with the same
-   * frameId is created. Consequently getFrame() will return a different
-   * ResourceTreeFrame after detachment. Callers of getFrame() should therefore
-   * immediately use the function return value and not store it for later use.
-   */
-  getFrame(frameId: Protocol.Page.FrameId): ResourceTreeFrame|null {
-    const frameData = this.#frames.get(frameId);
-    if (frameData) {
-      return frameData.frame;
-    }
-    return null;
-  }
-
-  getAllFrames(): ResourceTreeFrame[] {
-    return Array.from(this.#frames.values(), frameData => frameData.frame);
-  }
-
-  getOutermostFrame(): ResourceTreeFrame|null {
-    return this.#outermostFrame;
-  }
-
-  async getOrWaitForFrame(frameId: Protocol.Page.FrameId, notInTarget?: Target): Promise<ResourceTreeFrame> {
-    const frame = this.getFrame(frameId);
-    if (frame && (!notInTarget || notInTarget !== frame.resourceTreeModel().target())) {
-      return frame;
-    }
-    return await new Promise<ResourceTreeFrame>(resolve => {
-      const waiting = this.#awaitedFrames.get(frameId);
-      if (waiting) {
-        waiting.push({notInTarget, resolve});
-      } else {
-        this.#awaitedFrames.set(frameId, [{notInTarget, resolve}]);
-      }
-    });
-  }
-
-  private resolveAwaitedFrame(frame: ResourceTreeFrame): void {
-    const waiting = this.#awaitedFrames.get(frame.id);
-    if (!waiting) {
-      return;
-    }
-    const newWaiting = waiting.filter(({notInTarget, resolve}) => {
-      if (!notInTarget || notInTarget !== frame.resourceTreeModel().target()) {
-        resolve(frame);
-        return false;
-      }
-      return true;
-    });
-    if (newWaiting.length > 0) {
-      this.#awaitedFrames.set(frame.id, newWaiting);
-    } else {
-      this.#awaitedFrames.delete(frame.id);
-    }
-  }
-}
-
-export const enum Events {
-  // The FrameAddedToTarget event is sent whenever a frame is added to a target.
-  // This means that for OOPIFs it is sent twice: once when it's added to a
-  // parent target and a second time when it's added to its own target.
-  FRAME_ADDED_TO_TARGET = 'FrameAddedToTarget',
-  FRAME_NAVIGATED = 'FrameNavigated',
-  // The FrameRemoved event is only sent when a frame has been detached from
-  // all targets.
-  FRAME_REMOVED = 'FrameRemoved',
-  RESOURCE_ADDED = 'ResourceAdded',
-  OUTERMOST_FRAME_NAVIGATED = 'OutermostFrameNavigated',
-}
-
-export interface EventTypes {
-  [Events.FRAME_ADDED_TO_TARGET]: {frame: ResourceTreeFrame};
-  [Events.FRAME_NAVIGATED]: {frame: ResourceTreeFrame};
-  [Events.FRAME_REMOVED]: {frameId: Protocol.Page.FrameId};
-  [Events.RESOURCE_ADDED]: {resource: Resource};
-  [Events.OUTERMOST_FRAME_NAVIGATED]: {frame: ResourceTreeFrame};
-}

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

@@ -1,225 +0,0 @@
-// Copyright 2020 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 ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
-import type * as Protocol from '../../generated/protocol.js';
-import type * as Platform from '../platform/platform.js';
-
-import type {DebuggerModel} from './DebuggerModel.js';
-import type {RemoteObject} from './RemoteObject.js';
-import {RuntimeModel} from './RuntimeModel.js';
-import {SDKModel} from './SDKModel.js';
-import {Capability, type Target} from './Target.js';
-
-export class HeapProfilerModel extends SDKModel<EventTypes> {
-  #enabled: boolean;
-  readonly #heapProfilerAgent: ProtocolProxyApi.HeapProfilerApi;
-  readonly #runtimeModel: RuntimeModel;
-  #samplingProfilerDepth: number;
-
-  constructor(target: Target) {
-    super(target);
-    target.registerHeapProfilerDispatcher(new HeapProfilerDispatcher(this));
-    this.#enabled = false;
-    this.#heapProfilerAgent = target.heapProfilerAgent();
-    this.#runtimeModel = (target.model(RuntimeModel) as RuntimeModel);
-    this.#samplingProfilerDepth = 0;
-  }
-
-  debuggerModel(): DebuggerModel {
-    return this.#runtimeModel.debuggerModel();
-  }
-
-  runtimeModel(): RuntimeModel {
-    return this.#runtimeModel;
-  }
-
-  async enable(): Promise<void> {
-    if (this.#enabled) {
-      return;
-    }
-
-    this.#enabled = true;
-    await this.#heapProfilerAgent.invoke_enable();
-  }
-
-  async startSampling(samplingRateInBytes?: number): Promise<boolean> {
-    if (this.#samplingProfilerDepth++) {
-      return false;
-    }
-    const defaultSamplingIntervalInBytes = 16384;
-    const response = await this.#heapProfilerAgent.invoke_startSampling(
-        {samplingInterval: samplingRateInBytes || defaultSamplingIntervalInBytes});
-    return Boolean(response.getError());
-  }
-
-  async stopSampling(): Promise<Protocol.HeapProfiler.SamplingHeapProfile|null> {
-    if (!this.#samplingProfilerDepth) {
-      throw new Error('Sampling profiler is not running.');
-    }
-    if (--this.#samplingProfilerDepth) {
-      return await this.getSamplingProfile();
-    }
-    const response = await this.#heapProfilerAgent.invoke_stopSampling();
-    if (response.getError()) {
-      return null;
-    }
-    return response.profile;
-  }
-
-  async getSamplingProfile(): Promise<Protocol.HeapProfiler.SamplingHeapProfile|null> {
-    const response = await this.#heapProfilerAgent.invoke_getSamplingProfile();
-    if (response.getError()) {
-      return null;
-    }
-    return response.profile;
-  }
-
-  async collectGarbage(): Promise<boolean> {
-    const response = await this.#heapProfilerAgent.invoke_collectGarbage();
-    return Boolean(response.getError());
-  }
-
-  async snapshotObjectIdForObjectId(objectId: Protocol.Runtime.RemoteObjectId): Promise<string|null> {
-    const response = await this.#heapProfilerAgent.invoke_getHeapObjectId({objectId});
-    if (response.getError()) {
-      return null;
-    }
-    return response.heapSnapshotObjectId;
-  }
-
-  async objectForSnapshotObjectId(
-      snapshotObjectId: Protocol.HeapProfiler.HeapSnapshotObjectId,
-      objectGroupName: string): Promise<RemoteObject|null> {
-    const result = await this.#heapProfilerAgent.invoke_getObjectByHeapObjectId(
-        {objectId: snapshotObjectId, objectGroup: objectGroupName});
-    if (result.getError()) {
-      return null;
-    }
-    return this.#runtimeModel.createRemoteObject(result.result);
-  }
-
-  async addInspectedHeapObject(snapshotObjectId: Protocol.HeapProfiler.HeapSnapshotObjectId): Promise<boolean> {
-    const response = await this.#heapProfilerAgent.invoke_addInspectedHeapObject({heapObjectId: snapshotObjectId});
-    return Boolean(response.getError());
-  }
-
-  async takeHeapSnapshot(heapSnapshotOptions: Protocol.HeapProfiler.TakeHeapSnapshotRequest): Promise<void> {
-    await this.#heapProfilerAgent.invoke_takeHeapSnapshot(heapSnapshotOptions);
-  }
-
-  async startTrackingHeapObjects(recordAllocationStacks: boolean): Promise<boolean> {
-    const response =
-        await this.#heapProfilerAgent.invoke_startTrackingHeapObjects({trackAllocations: recordAllocationStacks});
-    return Boolean(response.getError());
-  }
-
-  async stopTrackingHeapObjects(reportProgress: boolean): Promise<boolean> {
-    const response = await this.#heapProfilerAgent.invoke_stopTrackingHeapObjects({reportProgress});
-    return Boolean(response.getError());
-  }
-
-  heapStatsUpdate(samples: number[]): void {
-    this.dispatchEventToListeners(Events.HEAP_STATS_UPDATED, samples);
-  }
-
-  lastSeenObjectId(lastSeenObjectId: number, timestamp: number): void {
-    this.dispatchEventToListeners(Events.LAST_SEEN_OBJECT_ID, {lastSeenObjectId, timestamp});
-  }
-
-  addHeapSnapshotChunk(chunk: string): void {
-    this.dispatchEventToListeners(Events.ADD_HEAP_SNAPSHOT_CHUNK, chunk);
-  }
-
-  reportHeapSnapshotProgress(done: number, total: number, finished?: boolean): void {
-    this.dispatchEventToListeners(Events.REPORT_HEAP_SNAPSHOT_PROGRESS, {done, total, finished});
-  }
-
-  resetProfiles(): void {
-    this.dispatchEventToListeners(Events.RESET_PROFILES, this);
-  }
-}
-
-export const enum Events {
-  HEAP_STATS_UPDATED = 'HeapStatsUpdate',
-  LAST_SEEN_OBJECT_ID = 'LastSeenObjectId',
-  ADD_HEAP_SNAPSHOT_CHUNK = 'AddHeapSnapshotChunk',
-  REPORT_HEAP_SNAPSHOT_PROGRESS = 'ReportHeapSnapshotProgress',
-  RESET_PROFILES = 'ResetProfiles',
-}
-
-/**
- * An array of triplets. Each triplet describes a fragment. The first number is the fragment
- * index, the second number is a total count of objects for the fragment, the third number is
- * a total size of the objects for the fragment.
- */
-export type HeapStatsUpdateSamples = number[];
-
-export interface LastSeenObjectId {
-  lastSeenObjectId: number;
-  timestamp: number;
-}
-
-export interface HeapSnapshotProgress {
-  done: number;
-  total: number;
-  finished?: boolean;
-}
-
-export interface EventTypes {
-  [Events.HEAP_STATS_UPDATED]: HeapStatsUpdateSamples;
-  [Events.LAST_SEEN_OBJECT_ID]: LastSeenObjectId;
-  [Events.ADD_HEAP_SNAPSHOT_CHUNK]: string;
-  [Events.REPORT_HEAP_SNAPSHOT_PROGRESS]: HeapSnapshotProgress;
-  [Events.RESET_PROFILES]: HeapProfilerModel;
-}
-
-export interface NativeProfilerCallFrame {
-  functionName: string;
-  url: Platform.DevToolsPath.UrlString;
-  scriptId?: string;
-  lineNumber?: number;
-  columnNumber?: number;
-}
-
-export interface CommonHeapProfileNode {
-  callFrame: NativeProfilerCallFrame;
-  selfSize: number;
-  id?: number;
-  children: CommonHeapProfileNode[];
-}
-
-export interface CommonHeapProfile {
-  head: CommonHeapProfileNode;
-  modules: Protocol.Memory.Module[];
-}
-
-class HeapProfilerDispatcher implements ProtocolProxyApi.HeapProfilerDispatcher {
-  readonly #heapProfilerModel: HeapProfilerModel;
-  constructor(model: HeapProfilerModel) {
-    this.#heapProfilerModel = model;
-  }
-
-  heapStatsUpdate({statsUpdate}: Protocol.HeapProfiler.HeapStatsUpdateEvent): void {
-    this.#heapProfilerModel.heapStatsUpdate(statsUpdate);
-  }
-
-  lastSeenObjectId({lastSeenObjectId, timestamp}: Protocol.HeapProfiler.LastSeenObjectIdEvent): void {
-    this.#heapProfilerModel.lastSeenObjectId(lastSeenObjectId, timestamp);
-  }
-
-  addHeapSnapshotChunk({chunk}: Protocol.HeapProfiler.AddHeapSnapshotChunkEvent): void {
-    this.#heapProfilerModel.addHeapSnapshotChunk(chunk);
-  }
-
-  reportHeapSnapshotProgress({done, total, finished}: Protocol.HeapProfiler.ReportHeapSnapshotProgressEvent): void {
-    this.#heapProfilerModel.reportHeapSnapshotProgress(done, total, finished);
-  }
-
-  resetProfiles(): void {
-    this.#heapProfilerModel.resetProfiles();
-  }
-}
-
-SDKModel.register(HeapProfilerModel, {capabilities: Capability.JS, autostart: false});

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

@@ -1,77 +0,0 @@
-// 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 i18n from '../i18n/i18n.js';
-
-/**
- * Reason phrase sources
- * See https://www.rfc-editor.org/rfc/rfc9110.html#name-status-codes
- **/
-export function getStatusText(statusCode: number): string {
-  const statusTextLookup: Record<number, string> = {
-    100: 'Continue',
-    101: 'Switching Protocols',
-    102: 'Processing',
-    103: 'Early Hints',
-    200: 'OK',
-    201: 'Created',
-    202: 'Accepted',
-    203: 'Non-Authoritative Information',
-    204: 'No Content',
-    205: 'Reset Content',
-    206: 'Partial Content',
-    207: 'Multi-Status',
-    208: 'Already Reported',
-    226: 'IM Used',
-    300: 'Multiple Choices',
-    301: 'Moved Permanently',
-    302: 'Found',
-    303: 'See Other',
-    304: 'Not Modified',
-    305: 'Use Proxy',
-    307: 'Temporary Redirect',
-    308: 'Permanent Redirect',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    402: 'Payment Required',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    406: 'Not Acceptable',
-    407: 'Proxy Authentication Required',
-    408: 'Request Timeout',
-    409: 'Conflict',
-    410: 'Gone',
-    411: 'Length Required',
-    412: 'Precondition Failed',
-    413: 'Content Too Large',
-    414: 'URI Too Long',
-    415: 'Unsupported Media Type',
-    416: 'Range Not Satisfiable',
-    417: 'Expectation Failed',
-    418: 'I\'m a teapot',
-    421: 'Misdirected Request',
-    422: 'Unprocessable Content',
-    423: 'Locked',
-    424: 'Failed Dependency',
-    425: 'Too Early',
-    426: 'Upgrade Required',
-    428: 'Precondition Required',
-    429: 'Too Many Requests',
-    431: 'Request Header Fields Too Large',
-    451: 'Unavailable For Legal Reasons',
-    500: 'Internal Server Error',
-    501: 'Not Implemented',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-    505: 'HTTP Version Not Supported',
-    506: 'Variant Also Negotiates',
-    507: 'Insufficient Storage',
-    508: 'Loop Detected',
-    510: 'Not Extended',
-    511: 'Network Authentication Required',
-  };
-  return i18n.i18n.lockedString(statusTextLookup[statusCode] ?? '');
-}

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

@@ -1,91 +0,0 @@
-// Copyright 2020 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 Protocol from '../../generated/protocol.js';
-import * as Common from '../common/common.js';
-
-import {RemoteObject} from './RemoteObject.js';
-import {SDKModel} from './SDKModel.js';
-import {Capability} from './Target.js';
-
-export class IOModel extends SDKModel<void> {
-  async read(handle: Protocol.IO.StreamHandle, size?: number, offset?: number): Promise<string|Uint8Array|null> {
-    const result = await this.target().ioAgent().invoke_read({handle, offset, size});
-    if (result.getError()) {
-      throw new Error(result.getError());
-    }
-    if (result.eof) {
-      return null;
-    }
-    if (result.base64Encoded) {
-      return Common.Base64.decode(result.data);
-    }
-    return result.data;
-  }
-
-  async close(handle: Protocol.IO.StreamHandle): Promise<void> {
-    const result = await this.target().ioAgent().invoke_close({handle});
-    if (result.getError()) {
-      console.error('Could not close stream.');
-    }
-  }
-
-  async resolveBlob(objectOrObjectId: Protocol.Runtime.RemoteObjectId|RemoteObject): Promise<string> {
-    const objectId = objectOrObjectId instanceof RemoteObject ? objectOrObjectId.objectId : objectOrObjectId;
-    if (!objectId) {
-      throw new Error('Remote object has undefined objectId');
-    }
-    const result = await this.target().ioAgent().invoke_resolveBlob({objectId});
-    if (result.getError()) {
-      throw new Error(result.getError());
-    }
-    return `blob:${result.uuid}`;
-  }
-
-  async readToString(handle: Protocol.IO.StreamHandle): Promise<string> {
-    const strings: string[] = [];
-    const decoder = new TextDecoder();
-    for (;;) {
-      const data = await this.read(handle, 1024 * 1024);
-      if (data === null) {
-        strings.push(decoder.decode());
-        break;
-      }
-      if (data instanceof Uint8Array) {
-        strings.push(decoder.decode(data, {stream: true}));
-      } else {
-        strings.push(data);
-      }
-    }
-    return strings.join('');
-  }
-
-  async readToBuffer(handle: Protocol.IO.StreamHandle): Promise<Uint8Array<ArrayBuffer>> {
-    const items: Uint8Array[] = [];
-    for (;;) {
-      const data = await this.read(handle, 1024 * 1024);
-      if (data === null) {
-        break;
-      }
-      if (data instanceof Uint8Array) {
-        items.push(data);
-      } else {
-        throw new Error('Unexpected stream data type: expected binary, got a string');
-      }
-    }
-    let length = 0;
-    for (const item of items) {
-      length += item.length;
-    }
-    const result = new Uint8Array(length);
-    let offset = 0;
-    for (const item of items) {
-      result.set(item, offset);
-      offset += item.length;
-    }
-    return result;
-  }
-}
-
-SDKModel.register(IOModel, {capabilities: Capability.IO, autostart: true});