devtools-tracing 1.1.1 → 1.2.1

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

@@ -1,435 +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 * as Host from '../host/host.js';
-import * as i18n from '../i18n/i18n.js';
-import type * as Platform from '../platform/platform.js';
-
-import {FrameManager} from './FrameManager.js';
-import {IOModel} from './IOModel.js';
-import {MultitargetNetworkManager, NetworkManager} from './NetworkManager.js';
-import {
-  Events as ResourceTreeModelEvents,
-  PrimaryPageChangeType,
-  type ResourceTreeFrame,
-  ResourceTreeModel,
-} from './ResourceTreeModel.js';
-import type {Target} from './Target.js';
-import {TargetManager} from './TargetManager.js';
-
-const UIStrings = {
-  /**
-   * @description Error message for canceled source map loads
-   */
-  loadCanceledDueToReloadOf: 'Load canceled due to reload of inspected page',
-} as const;
-const str_ = i18n.i18n.registerUIStrings('core/sdk/PageResourceLoader.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-
-export interface ExtensionInitiator {
-  target: null;
-  frameId: null;
-  initiatorUrl: Platform.DevToolsPath.UrlString;
-  extensionId: string;
-}
-
-export type PageResourceLoadInitiator = {
-  target: null,
-  frameId: Protocol.Page.FrameId,
-  initiatorUrl: Platform.DevToolsPath.UrlString|null,
-}|{
-  target: Target,
-  frameId: Protocol.Page.FrameId | null,
-  initiatorUrl: Platform.DevToolsPath.UrlString | null,
-}|ExtensionInitiator;
-
-function isExtensionInitiator(initiator: PageResourceLoadInitiator): initiator is ExtensionInitiator {
-  return 'extensionId' in initiator;
-}
-
-export interface PageResource {
-  success: boolean|null;
-  errorMessage?: string;
-  initiator: PageResourceLoadInitiator;
-  url: Platform.DevToolsPath.UrlString;
-  size: number|null;
-  duration: number|null;
-}
-
-/** Used for revealing a resource. **/
-export class ResourceKey {
-  readonly key: string;
-
-  constructor(key: string) {
-    this.key = key;
-  }
-}
-
-let pageResourceLoader: PageResourceLoader|null = null;
-
-interface LoadQueueEntry {
-  resolve: () => void;
-  reject: (arg0: Error) => void;
-}
-
-/**
- * The page resource loader is a bottleneck for all DevTools-initiated resource loads. For each such load, it keeps a
- * `PageResource` object around that holds meta information. This can be as the basis for reporting to the user which
- * resources were loaded, and whether there was a load error.
- */
-export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
-  #currentlyLoading = 0;
-  #currentlyLoadingPerTarget = new Map<Protocol.Target.TargetID|'main', number>();
-  readonly #maxConcurrentLoads: number;
-  #pageResources = new Map<string, PageResource>();
-  #queuedLoads: LoadQueueEntry[] = [];
-  readonly #loadOverride: ((arg0: string) => Promise<{
-                             success: boolean,
-                             content: string,
-                             errorDescription: Host.ResourceLoader.LoadErrorDescription,
-                           }>)|null;
-  constructor(
-      loadOverride: ((arg0: string) => Promise<{
-                       success: boolean,
-                       content: string,
-                       errorDescription: Host.ResourceLoader.LoadErrorDescription,
-                     }>)|null,
-      maxConcurrentLoads: number) {
-    super();
-    this.#maxConcurrentLoads = maxConcurrentLoads;
-    TargetManager.instance().addModelListener(
-        ResourceTreeModel, ResourceTreeModelEvents.PrimaryPageChanged, this.onPrimaryPageChanged, this);
-    this.#loadOverride = loadOverride;
-  }
-
-  static instance({forceNew, loadOverride, maxConcurrentLoads}: {
-    forceNew: boolean,
-    loadOverride: (null|((arg0: string) => Promise<{
-                           success: boolean,
-                           content: string,
-                           errorDescription: Host.ResourceLoader.LoadErrorDescription,
-                         }>)),
-    maxConcurrentLoads: number,
-  } = {
-    forceNew: false,
-    loadOverride: null,
-    maxConcurrentLoads: 500,
-  }): PageResourceLoader {
-    if (!pageResourceLoader || forceNew) {
-      pageResourceLoader = new PageResourceLoader(loadOverride, maxConcurrentLoads);
-    }
-
-    return pageResourceLoader;
-  }
-
-  static removeInstance(): void {
-    pageResourceLoader = null;
-  }
-
-  onPrimaryPageChanged(
-      event: Common.EventTarget.EventTargetEvent<{frame: ResourceTreeFrame, type: PrimaryPageChangeType}>): void {
-    const {frame: mainFrame, type} = event.data;
-    if (!mainFrame.isOutermostFrame()) {
-      return;
-    }
-    for (const {reject} of this.#queuedLoads) {
-      reject(new Error(i18nString(UIStrings.loadCanceledDueToReloadOf)));
-    }
-    this.#queuedLoads = [];
-    const mainFrameTarget = mainFrame.resourceTreeModel().target();
-    const keptResources = new Map<string, PageResource>();
-    // If the navigation is a prerender-activation, the pageResources for the destination page have
-    // already been preloaded. In such cases, we therefore don't just discard all pageResources, but
-    // instead make sure to keep the pageResources for the prerendered target.
-    for (const [key, pageResource] of this.#pageResources.entries()) {
-      if ((type === PrimaryPageChangeType.ACTIVATION) && mainFrameTarget === pageResource.initiator.target) {
-        keptResources.set(key, pageResource);
-      }
-    }
-    this.#pageResources = keptResources;
-    this.dispatchEventToListeners(Events.UPDATE);
-  }
-
-  getResourcesLoaded(): Map<string, PageResource> {
-    return this.#pageResources;
-  }
-
-  getScopedResourcesLoaded(): Map<string, PageResource> {
-    return new Map([...this.#pageResources].filter(
-        ([_, pageResource]) => TargetManager.instance().isInScope(pageResource.initiator.target) ||
-            isExtensionInitiator(pageResource.initiator)));
-  }
-
-  /**
-   * Loading is the number of currently loading and queued items. Resources is the total number of resources,
-   * including loading and queued resources, but not including resources that are still loading but scheduled
-   * for cancelation.;
-   */
-  getNumberOfResources(): {
-    loading: number,
-    queued: number,
-    resources: number,
-  } {
-    return {loading: this.#currentlyLoading, queued: this.#queuedLoads.length, resources: this.#pageResources.size};
-  }
-
-  getScopedNumberOfResources(): {
-    loading: number,
-    resources: number,
-  } {
-    const targetManager = TargetManager.instance();
-    let loadingCount = 0;
-    for (const [targetId, count] of this.#currentlyLoadingPerTarget) {
-      const target = targetManager.targetById(targetId);
-      if (targetManager.isInScope(target)) {
-        loadingCount += count;
-      }
-    }
-    return {loading: loadingCount, resources: this.getScopedResourcesLoaded().size};
-  }
-
-  private async acquireLoadSlot(target: Target|null): Promise<void> {
-    this.#currentlyLoading++;
-    if (target) {
-      const currentCount = this.#currentlyLoadingPerTarget.get(target.id()) || 0;
-      this.#currentlyLoadingPerTarget.set(target.id(), currentCount + 1);
-    }
-    if (this.#currentlyLoading > this.#maxConcurrentLoads) {
-      const {
-        promise: waitForCapacity,
-        resolve,
-        reject,
-      } = Promise.withResolvers<void>();
-      this.#queuedLoads.push({resolve, reject});
-      await waitForCapacity;
-    }
-  }
-
-  private releaseLoadSlot(target: Target|null): void {
-    this.#currentlyLoading--;
-    if (target) {
-      const currentCount = this.#currentlyLoadingPerTarget.get(target.id());
-      if (currentCount) {
-        this.#currentlyLoadingPerTarget.set(target.id(), currentCount - 1);
-      }
-    }
-    const entry = this.#queuedLoads.shift();
-    if (entry) {
-      entry.resolve();
-    }
-  }
-
-  static makeExtensionKey(url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator): string {
-    if (isExtensionInitiator(initiator) && initiator.extensionId) {
-      return `${url}-${initiator.extensionId}`;
-    }
-    throw new Error('Invalid initiator');
-  }
-
-  static makeKey(url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator): string {
-    if (initiator.frameId) {
-      return `${url}-${initiator.frameId}`;
-    }
-    if (initiator.target) {
-      return `${url}-${initiator.target.id()}`;
-    }
-    throw new Error('Invalid initiator');
-  }
-
-  resourceLoadedThroughExtension(pageResource: PageResource): void {
-    const key = PageResourceLoader.makeExtensionKey(pageResource.url, pageResource.initiator);
-    this.#pageResources.set(key, pageResource);
-    this.dispatchEventToListeners(Events.UPDATE);
-  }
-
-  loadResource(url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator, isBinary: true): Promise<{
-    content: Uint8Array<ArrayBuffer>,
-  }>;
-  loadResource(url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator, isBinary?: false): Promise<{
-    content: string,
-  }>;
-  async loadResource(url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator, isBinary = false):
-      Promise<{
-        content: string | Uint8Array<ArrayBuffer>,
-      }> {
-    if (isExtensionInitiator(initiator)) {
-      throw new Error('Invalid initiator');
-    }
-    const key = PageResourceLoader.makeKey(url, initiator);
-    const pageResource:
-        PageResource = {success: null, size: null, duration: null, errorMessage: undefined, url, initiator};
-    this.#pageResources.set(key, pageResource);
-    this.dispatchEventToListeners(Events.UPDATE);
-    const startTime = performance.now();
-    try {
-      await this.acquireLoadSlot(initiator.target);
-      const resultPromise = this.dispatchLoad(url, initiator, isBinary);
-      const result = await resultPromise;
-      pageResource.errorMessage = result.errorDescription.message;
-      pageResource.success = result.success;
-      if (result.success) {
-        pageResource.size = result.content.length;
-        return {content: result.content};
-      }
-      throw new Error(result.errorDescription.message);
-    } catch (e) {
-      if (pageResource.errorMessage === undefined) {
-        pageResource.errorMessage = e.message;
-      }
-      if (pageResource.success === null) {
-        pageResource.success = false;
-      }
-      throw e;
-    } finally {
-      pageResource.duration = performance.now() - startTime;
-      this.releaseLoadSlot(initiator.target);
-      this.dispatchEventToListeners(Events.UPDATE);
-    }
-  }
-
-  private async dispatchLoad(
-      url: Platform.DevToolsPath.UrlString, initiator: PageResourceLoadInitiator, isBinary: boolean): Promise<{
-    success: boolean,
-    content: string|Uint8Array<ArrayBuffer>,
-    errorDescription: Host.ResourceLoader.LoadErrorDescription,
-  }> {
-    if (isExtensionInitiator(initiator)) {
-      throw new Error('Invalid initiator');
-    }
-
-    const failureReason: string|null = null;
-    if (this.#loadOverride) {
-      return await this.#loadOverride(url);
-    }
-    const parsedURL = new Common.ParsedURL.ParsedURL(url);
-    const eligibleForLoadFromTarget = getLoadThroughTargetSetting().get() && parsedURL && parsedURL.scheme !== 'file' &&
-        parsedURL.scheme !== 'data' && parsedURL.scheme !== 'devtools';
-    Host.userMetrics.developerResourceScheme(this.getDeveloperResourceScheme(parsedURL));
-    if (eligibleForLoadFromTarget) {
-      try {
-        if (initiator.target) {
-          Host.userMetrics.developerResourceLoaded(
-              Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_TARGET);
-          const result = await this.loadFromTarget(initiator.target, initiator.frameId, url, isBinary);
-          return result;
-        }
-        const frame = FrameManager.instance().getFrame(initiator.frameId);
-        if (frame) {
-          Host.userMetrics.developerResourceLoaded(
-              Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_VIA_FRAME);
-          const result =
-              await this.loadFromTarget(frame.resourceTreeModel().target(), initiator.frameId, url, isBinary);
-          return result;
-        }
-      } catch (e) {
-        if (e instanceof Error) {
-          Host.userMetrics.developerResourceLoaded(Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FAILURE);
-          if (e.message.includes('CSP violation')) {
-            return {
-              success: false,
-              content: '',
-              errorDescription:
-                  {statusCode: 0, netError: undefined, netErrorName: undefined, message: e.message, urlValid: undefined}
-            };
-          }
-        }
-      }
-      Host.userMetrics.developerResourceLoaded(Host.UserMetrics.DeveloperResourceLoaded.LOAD_THROUGH_PAGE_FALLBACK);
-    } else {
-      const code = getLoadThroughTargetSetting().get() ?
-          Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_PROTOCOL :
-          Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_PER_OVERRIDE;
-      Host.userMetrics.developerResourceLoaded(code);
-    }
-
-    const result = await MultitargetNetworkManager.instance().loadResource(url);
-    if (eligibleForLoadFromTarget && !result.success) {
-      Host.userMetrics.developerResourceLoaded(Host.UserMetrics.DeveloperResourceLoaded.FALLBACK_FAILURE);
-    }
-    if (failureReason) {
-      // In case we have a success, add a note about why the load through the target failed.
-      result.errorDescription.message =
-          `Fetch through target failed: ${failureReason}; Fallback: ${result.errorDescription.message}`;
-    }
-    return result;
-  }
-
-  private getDeveloperResourceScheme(parsedURL: Common.ParsedURL.ParsedURL|null):
-      Host.UserMetrics.DeveloperResourceScheme {
-    if (!parsedURL || parsedURL.scheme === '') {
-      return Host.UserMetrics.DeveloperResourceScheme.UKNOWN;
-    }
-    const isLocalhost = parsedURL.host === 'localhost' || parsedURL.host.endsWith('.localhost');
-    switch (parsedURL.scheme) {
-      case 'file':
-        return Host.UserMetrics.DeveloperResourceScheme.FILE;
-      case 'data':
-        return Host.UserMetrics.DeveloperResourceScheme.DATA;
-      case 'blob':
-        return Host.UserMetrics.DeveloperResourceScheme.BLOB;
-      case 'http':
-        return isLocalhost ? Host.UserMetrics.DeveloperResourceScheme.HTTP_LOCALHOST :
-                             Host.UserMetrics.DeveloperResourceScheme.HTTP;
-      case 'https':
-        return isLocalhost ? Host.UserMetrics.DeveloperResourceScheme.HTTPS_LOCALHOST :
-                             Host.UserMetrics.DeveloperResourceScheme.HTTPS;
-    }
-    return Host.UserMetrics.DeveloperResourceScheme.OTHER;
-  }
-
-  private async loadFromTarget(
-      target: Target, frameId: Protocol.Page.FrameId|null, url: Platform.DevToolsPath.UrlString,
-      isBinary: boolean): Promise<{
-    success: boolean,
-    content: string|Uint8Array<ArrayBuffer>,
-    errorDescription: {
-      statusCode: number,
-      netError: number|undefined,
-      netErrorName: string|undefined,
-      message: string,
-      urlValid: undefined,
-    },
-  }> {
-    const networkManager = (target.model(NetworkManager) as NetworkManager);
-    const ioModel = (target.model(IOModel) as IOModel);
-    const disableCache = Common.Settings.Settings.instance().moduleSetting('cache-disabled').get();
-    const resource = await networkManager.loadNetworkResource(frameId, url, {disableCache, includeCredentials: true});
-    try {
-      const content = resource.stream ?
-          (isBinary ? await ioModel.readToBuffer(resource.stream) : await ioModel.readToString(resource.stream)) :
-          '';
-      return {
-        success: resource.success,
-        content,
-        errorDescription: {
-          statusCode: resource.httpStatusCode || 0,
-          netError: resource.netError,
-          netErrorName: resource.netErrorName,
-          message: Host.ResourceLoader.netErrorToMessage(
-                       resource.netError, resource.httpStatusCode, resource.netErrorName) ||
-              '',
-          urlValid: undefined,
-        },
-      };
-    } finally {
-      if (resource.stream) {
-        void ioModel.close(resource.stream);
-      }
-    }
-  }
-}
-
-export function getLoadThroughTargetSetting(): Common.Settings.Setting<boolean> {
-  return Common.Settings.Settings.instance().createSetting('load-through-target', true);
-}
-
-export const enum Events {
-  UPDATE = 'Update',
-}
-
-export interface EventTypes {
-  [Events.UPDATE]: void;
-}

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

@@ -1,110 +0,0 @@
-// 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 type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
-import type * as Protocol from '../../generated/protocol.js';
-
-import {SDKModel} from './SDKModel.js';
-import {Capability, type Target} from './Target.js';
-
-export class PaintProfilerModel extends SDKModel<void> {
-  readonly layerTreeAgent: ProtocolProxyApi.LayerTreeApi;
-
-  constructor(target: Target) {
-    super(target);
-    this.layerTreeAgent = target.layerTreeAgent();
-  }
-
-  async loadSnapshotFromFragments(tiles: Protocol.LayerTree.PictureTile[]): Promise<PaintProfilerSnapshot|null> {
-    const {snapshotId} = await this.layerTreeAgent.invoke_loadSnapshot({tiles});
-    return snapshotId ? new PaintProfilerSnapshot(this, snapshotId) : null;
-  }
-
-  loadSnapshot(encodedPicture: Protocol.binary): Promise<PaintProfilerSnapshot|null> {
-    const fragment = {x: 0, y: 0, picture: encodedPicture};
-    return this.loadSnapshotFromFragments([fragment]);
-  }
-
-  async makeSnapshot(layerId: Protocol.LayerTree.LayerId): Promise<PaintProfilerSnapshot|null> {
-    const {snapshotId} = await this.layerTreeAgent.invoke_makeSnapshot({layerId});
-    return snapshotId ? new PaintProfilerSnapshot(this, snapshotId) : null;
-  }
-}
-
-export class PaintProfilerSnapshot {
-  readonly #paintProfilerModel: PaintProfilerModel;
-  readonly #id: Protocol.LayerTree.SnapshotId;
-  #refCount: number;
-
-  constructor(paintProfilerModel: PaintProfilerModel, snapshotId: Protocol.LayerTree.SnapshotId) {
-    this.#paintProfilerModel = paintProfilerModel;
-    this.#id = snapshotId;
-    this.#refCount = 1;
-  }
-
-  release(): void {
-    console.assert(this.#refCount > 0, 'release is already called on the object');
-    if (!--this.#refCount) {
-      void this.#paintProfilerModel.layerTreeAgent.invoke_releaseSnapshot({snapshotId: this.#id});
-    }
-  }
-
-  addReference(): void {
-    ++this.#refCount;
-    console.assert(this.#refCount > 0, 'Referencing a dead object');
-  }
-
-  async replay(scale?: number, fromStep?: number, toStep?: number): Promise<string|null> {
-    const response = await this.#paintProfilerModel.layerTreeAgent.invoke_replaySnapshot(
-        {snapshotId: this.#id, fromStep, toStep, scale: scale || 1.0});
-    return response.dataURL;
-  }
-
-  async profile(clipRect: Protocol.DOM.Rect|null): Promise<Protocol.LayerTree.PaintProfile[]> {
-    const response = await this.#paintProfilerModel.layerTreeAgent.invoke_profileSnapshot(
-        {snapshotId: this.#id, minRepeatCount: 5, minDuration: 1, clipRect: clipRect || undefined});
-
-    return response.timings;
-  }
-
-  async commandLog(): Promise<PaintProfilerLogItem[]|null> {
-    const response = await this.#paintProfilerModel.layerTreeAgent.invoke_snapshotCommandLog({snapshotId: this.#id});
-
-    return response.commandLog ? response.commandLog.map((entry, index) => new PaintProfilerLogItem(entry, index)) :
-                                 null;
-  }
-}
-
-export class PaintProfilerLogItem {
-  method: string;
-  params: RawPaintProfilerLogItemParams|null;
-  commandIndex: number;
-
-  constructor(rawEntry: RawPaintProfilerLogItem, commandIndex: number) {
-    this.method = rawEntry.method;
-    this.params = rawEntry.params;
-    this.commandIndex = commandIndex;
-  }
-}
-
-SDKModel.register(PaintProfilerModel, {capabilities: Capability.DOM, autostart: false});
-
-export type RawPaintProfilerLogItemParamValue = string|{[key: string]: RawPaintProfilerLogItemParamValue};
-export type RawPaintProfilerLogItemParams = Record<string, RawPaintProfilerLogItemParamValue>;
-
-export interface SnapshotWithRect {
-  rect: Protocol.DOM.Rect;
-  snapshot: PaintProfilerSnapshot;
-}
-
-export interface PictureFragment {
-  x: number;
-  y: number;
-  picture: string;
-}
-
-export interface RawPaintProfilerLogItem {
-  method: string;
-  params: RawPaintProfilerLogItemParams|null;
-}

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

@@ -1,84 +0,0 @@
-// Copyright 2017 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 * as Platform from '../platform/platform.js';
-
-import {SDKModel} from './SDKModel.js';
-import {Capability, type Target} from './Target.js';
-
-export class PerformanceMetricsModel extends SDKModel<void> {
-  readonly #agent: ProtocolProxyApi.PerformanceApi;
-  readonly #metricModes = new Map<string, MetricMode>([
-    ['TaskDuration', MetricMode.CUMULATIVE_TIME],
-    ['ScriptDuration', MetricMode.CUMULATIVE_TIME],
-    ['LayoutDuration', MetricMode.CUMULATIVE_TIME],
-    ['RecalcStyleDuration', MetricMode.CUMULATIVE_TIME],
-    ['LayoutCount', MetricMode.CUMULATIVE_COUNT],
-    ['RecalcStyleCount', MetricMode.CUMULATIVE_COUNT],
-  ]);
-  readonly #metricData = new Map<string, {
-    lastValue: (number | undefined),
-    lastTimestamp: (number|undefined),
-  }>();
-
-  constructor(target: Target) {
-    super(target);
-    this.#agent = target.performanceAgent();
-  }
-
-  enable(): Promise<Object> {
-    return this.#agent.invoke_enable({});
-  }
-
-  disable(): Promise<Object> {
-    return this.#agent.invoke_disable();
-  }
-
-  async requestMetrics(): Promise<{
-    metrics: Map<string, number>,
-    timestamp: number,
-  }> {
-    const rawMetrics = await this.#agent.invoke_getMetrics() || [];
-    const metrics = new Map<string, number>();
-    const timestamp = performance.now();
-    for (const metric of rawMetrics.metrics) {
-      let data = this.#metricData.get(metric.name);
-      if (!data) {
-        data = {lastValue: undefined, lastTimestamp: undefined};
-        this.#metricData.set(metric.name, data);
-      }
-      let value;
-      switch (this.#metricModes.get(metric.name)) {
-        case MetricMode.CUMULATIVE_TIME:
-          value = (data.lastTimestamp && data.lastValue) ?
-              Platform.NumberUtilities.clamp(
-                  (metric.value - data.lastValue) * 1000 / (timestamp - data.lastTimestamp), 0, 1) :
-              0;
-          data.lastValue = metric.value;
-          data.lastTimestamp = timestamp;
-          break;
-        case MetricMode.CUMULATIVE_COUNT:
-          value = (data.lastTimestamp && data.lastValue) ?
-              Math.max(0, (metric.value - data.lastValue) * 1000 / (timestamp - data.lastTimestamp)) :
-              0;
-          data.lastValue = metric.value;
-          data.lastTimestamp = timestamp;
-          break;
-        default:
-          value = metric.value;
-          break;
-      }
-      metrics.set(metric.name, value);
-    }
-    return {metrics, timestamp};
-  }
-}
-
-const enum MetricMode {
-  CUMULATIVE_TIME = 'CumulativeTime',
-  CUMULATIVE_COUNT = 'CumulativeCount',
-}
-
-SDKModel.register(PerformanceMetricsModel, {capabilities: Capability.DOM, autostart: false});