devtools-tracing 1.0.0

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

@@ -0,0 +1,808 @@
+// 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 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 * as Platform from '../platform/platform.js';
+
+import {FrontendMessageType} from './ConsoleModelTypes.js';
+import {CPUProfilerModel, type EventData, Events as CPUProfilerModelEvents} from './CPUProfilerModel.js';
+import {
+  BreakpointType,
+  COND_BREAKPOINT_SOURCE_URL,
+  Events as DebuggerModelEvents,
+  type Location,
+  LOGPOINT_SOURCE_URL,
+} from './DebuggerModel.js';
+import {LogModel} from './LogModel.js';
+import {RemoteObject} from './RemoteObject.js';
+import {
+  Events as ResourceTreeModelEvents,
+  type PrimaryPageChangeType,
+  type ResourceTreeFrame,
+  ResourceTreeModel,
+} from './ResourceTreeModel.js';
+import {
+  type ConsoleAPICall,
+  Events as RuntimeModelEvents,
+  type ExceptionWithTimestamp,
+  type ExecutionContext,
+  type QueryObjectRequestedEvent,
+  RuntimeModel,
+} from './RuntimeModel.js';
+import {SDKModel} from './SDKModel.js';
+import {Capability, type Target, Type} from './Target.js';
+import {TargetManager} from './TargetManager.js';
+
+export {FrontendMessageType} from './ConsoleModelTypes.js';
+
+const UIStrings = {
+  /**
+   * @description Text shown when the main frame (page) of the website was navigated to a different URL.
+   * @example {https://example.com} PH1
+   */
+  navigatedToS: 'Navigated to {PH1}',
+  /**
+   * @description Text shown when the main frame (page) of the website was navigated to a different URL
+   * and the page was restored from back/forward cache (https://web.dev/bfcache/).
+   * @example {https://example.com} PH1
+   */
+  bfcacheNavigation: 'Navigation to {PH1} was restored from back/forward cache (see https://web.dev/bfcache/)',
+  /**
+   * @description Text shown in the console when a performance profile (with the given name) was started.
+   * @example {title} PH1
+   */
+  profileSStarted: 'Profile \'\'{PH1}\'\' started.',
+  /**
+   * @description Text shown in the console when a performance profile (with the given name) was stopped.
+   * @example {name} PH1
+   */
+  profileSFinished: 'Profile \'\'{PH1}\'\' finished.',
+  /**
+   * @description Error message shown in the console after the user tries to save a JavaScript value to a temporary variable.
+   */
+  failedToSaveToTempVariable: 'Failed to save to temp variable.',
+} as const;
+
+const str_ = i18n.i18n.registerUIStrings('core/sdk/ConsoleModel.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+
+export class ConsoleModel extends SDKModel<EventTypes> {
+  #messages: ConsoleMessage[] = [];
+  readonly #messagesByTimestamp = new Platform.MapUtilities.Multimap<number, ConsoleMessage>();
+  readonly #messageByExceptionId = new Map<RuntimeModel, Map<number, ConsoleMessage>>();
+  #warnings = 0;
+  #errors = 0;
+  #violations = 0;
+  #pageLoadSequenceNumber = 0;
+  readonly #targetListeners = new WeakMap<Target, Common.EventTarget.EventDescriptor[]>();
+
+  constructor(target: Target) {
+    super(target);
+
+    const resourceTreeModel = target.model(ResourceTreeModel);
+    if (!resourceTreeModel || resourceTreeModel.cachedResourcesLoaded()) {
+      this.initTarget(target);
+      return;
+    }
+
+    const eventListener = resourceTreeModel.addEventListener(ResourceTreeModelEvents.CachedResourcesLoaded, () => {
+      Common.EventTarget.removeEventListeners([eventListener]);
+      this.initTarget(target);
+    });
+  }
+
+  private initTarget(target: Target): void {
+    const eventListeners = [];
+
+    const cpuProfilerModel = target.model(CPUProfilerModel);
+    if (cpuProfilerModel) {
+      eventListeners.push(cpuProfilerModel.addEventListener(
+          CPUProfilerModelEvents.CONSOLE_PROFILE_STARTED, this.consoleProfileStarted.bind(this, cpuProfilerModel)));
+      eventListeners.push(cpuProfilerModel.addEventListener(
+          CPUProfilerModelEvents.CONSOLE_PROFILE_FINISHED, this.consoleProfileFinished.bind(this, cpuProfilerModel)));
+    }
+
+    const resourceTreeModel = target.model(ResourceTreeModel);
+    if (resourceTreeModel && target.parentTarget()?.type() !== Type.FRAME) {
+      eventListeners.push(resourceTreeModel.addEventListener(
+          ResourceTreeModelEvents.PrimaryPageChanged, this.primaryPageChanged, this));
+    }
+
+    const runtimeModel = target.model(RuntimeModel);
+    if (runtimeModel) {
+      eventListeners.push(runtimeModel.addEventListener(
+          RuntimeModelEvents.ExceptionThrown, this.exceptionThrown.bind(this, runtimeModel)));
+      eventListeners.push(runtimeModel.addEventListener(
+          RuntimeModelEvents.ExceptionRevoked, this.exceptionRevoked.bind(this, runtimeModel)));
+      eventListeners.push(runtimeModel.addEventListener(
+          RuntimeModelEvents.ConsoleAPICalled, this.consoleAPICalled.bind(this, runtimeModel)));
+      if (target.parentTarget()?.type() !== Type.FRAME) {
+        eventListeners.push(runtimeModel.debuggerModel().addEventListener(
+            DebuggerModelEvents.GlobalObjectCleared, this.clearIfNecessary, this));
+      }
+      eventListeners.push(runtimeModel.addEventListener(
+          RuntimeModelEvents.QueryObjectRequested, this.queryObjectRequested.bind(this, runtimeModel)));
+    }
+
+    this.#targetListeners.set(target, eventListeners);
+  }
+
+  targetRemoved(target: Target): void {
+    const runtimeModel = target.model(RuntimeModel);
+    if (runtimeModel) {
+      this.#messageByExceptionId.delete(runtimeModel);
+    }
+    Common.EventTarget.removeEventListeners(this.#targetListeners.get(target) || []);
+  }
+
+  async evaluateCommandInConsole(
+      executionContext: ExecutionContext, originatingMessage: ConsoleMessage, expression: string,
+      useCommandLineAPI: boolean): Promise<void> {
+    const result = await executionContext.evaluate(
+        {
+          expression,
+          objectGroup: 'console',
+          includeCommandLineAPI: useCommandLineAPI,
+          silent: false,
+          returnByValue: false,
+          generatePreview: true,
+          replMode: true,
+          allowUnsafeEvalBlockedByCSP: false,
+        },
+        Common.Settings.Settings.instance().moduleSetting('console-user-activation-eval').get(),
+        /* awaitPromise */ false);
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.ConsoleEvaluated);
+    if ('error' in result) {
+      return;
+    }
+    await Common.Console.Console.instance().showPromise();
+    this.dispatchEventToListeners(
+        Events.CommandEvaluated,
+        {result: result.object, commandMessage: originatingMessage, exceptionDetails: result.exceptionDetails});
+  }
+
+  addCommandMessage(executionContext: ExecutionContext, text: string): ConsoleMessage {
+    const commandMessage = new ConsoleMessage(
+        executionContext.runtimeModel, Protocol.Log.LogEntrySource.Javascript, null, text,
+        {type: FrontendMessageType.Command});
+    commandMessage.setExecutionContextId(executionContext.id);
+    this.addMessage(commandMessage);
+    return commandMessage;
+  }
+
+  addMessage(msg: ConsoleMessage): void {
+    msg.setPageLoadSequenceNumber(this.#pageLoadSequenceNumber);
+    if (msg.source === Common.Console.FrontendMessageSource.ConsoleAPI &&
+        msg.type === Protocol.Runtime.ConsoleAPICalledEventType.Clear) {
+      this.clearIfNecessary();
+    }
+
+    this.#messages.push(msg);
+    this.#messagesByTimestamp.set(msg.timestamp, msg);
+    const runtimeModel = msg.runtimeModel();
+    const exceptionId = msg.getExceptionId();
+    if (exceptionId && runtimeModel) {
+      let modelMap = this.#messageByExceptionId.get(runtimeModel);
+      if (!modelMap) {
+        modelMap = new Map();
+        this.#messageByExceptionId.set(runtimeModel, modelMap);
+      }
+      modelMap.set(exceptionId, msg);
+    }
+    this.incrementErrorWarningCount(msg);
+    this.dispatchEventToListeners(Events.MessageAdded, msg);
+  }
+
+  private exceptionThrown(
+      runtimeModel: RuntimeModel, event: Common.EventTarget.EventTargetEvent<ExceptionWithTimestamp>): void {
+    const exceptionWithTimestamp = event.data;
+    const affectedResources = extractExceptionMetaData(exceptionWithTimestamp.details.exceptionMetaData);
+    const consoleMessage = ConsoleMessage.fromException(
+        runtimeModel, exceptionWithTimestamp.details, undefined, exceptionWithTimestamp.timestamp, undefined,
+        affectedResources);
+    consoleMessage.setExceptionId(exceptionWithTimestamp.details.exceptionId);
+    this.addMessage(consoleMessage);
+  }
+
+  private exceptionRevoked(runtimeModel: RuntimeModel, event: Common.EventTarget.EventTargetEvent<number>): void {
+    const exceptionId = event.data;
+    const modelMap = this.#messageByExceptionId.get(runtimeModel);
+    const exceptionMessage = modelMap ? modelMap.get(exceptionId) : null;
+    if (!exceptionMessage) {
+      return;
+    }
+    this.#errors--;
+    exceptionMessage.level = Protocol.Log.LogEntryLevel.Verbose;
+    this.dispatchEventToListeners(Events.MessageUpdated, exceptionMessage);
+  }
+
+  private consoleAPICalled(runtimeModel: RuntimeModel, event: Common.EventTarget.EventTargetEvent<ConsoleAPICall>):
+      void {
+    const call = event.data;
+    let level: Protocol.Log.LogEntryLevel = Protocol.Log.LogEntryLevel.Info;
+    if (call.type === Protocol.Runtime.ConsoleAPICalledEventType.Debug) {
+      level = Protocol.Log.LogEntryLevel.Verbose;
+    } else if (
+        call.type === Protocol.Runtime.ConsoleAPICalledEventType.Error ||
+        call.type === Protocol.Runtime.ConsoleAPICalledEventType.Assert) {
+      level = Protocol.Log.LogEntryLevel.Error;
+    } else if (call.type === Protocol.Runtime.ConsoleAPICalledEventType.Warning) {
+      level = Protocol.Log.LogEntryLevel.Warning;
+    } else if (
+        call.type === Protocol.Runtime.ConsoleAPICalledEventType.Info ||
+        call.type === Protocol.Runtime.ConsoleAPICalledEventType.Log) {
+      level = Protocol.Log.LogEntryLevel.Info;
+    }
+    let message = '';
+    if (call.args.length && call.args[0].unserializableValue) {
+      message = call.args[0].unserializableValue;
+    } else if (
+        call.args.length &&
+        ((typeof call.args[0].value !== 'object' && typeof call.args[0].value !== 'undefined') ||
+         call.args[0].value === null)) {
+      message = String(call.args[0].value);
+    } else if (call.args.length && call.args[0].description) {
+      message = call.args[0].description;
+    }
+    const callFrame = call.stackTrace?.callFrames.length ? call.stackTrace.callFrames[0] : null;
+    const details = {
+      type: call.type,
+      url: callFrame?.url as Platform.DevToolsPath.UrlString | undefined,
+      line: callFrame?.lineNumber,
+      column: callFrame?.columnNumber,
+      parameters: call.args,
+      stackTrace: call.stackTrace,
+      timestamp: call.timestamp,
+      executionContextId: call.executionContextId,
+      context: call.context,
+    };
+    const consoleMessage =
+        new ConsoleMessage(runtimeModel, Common.Console.FrontendMessageSource.ConsoleAPI, level, (message), details);
+    for (const msg of this.#messagesByTimestamp.get(consoleMessage.timestamp).values()) {
+      if (consoleMessage.isEqual(msg)) {
+        return;
+      }
+    }
+    this.addMessage(consoleMessage);
+  }
+
+  private queryObjectRequested(
+      runtimeModel: RuntimeModel, event: Common.EventTarget.EventTargetEvent<QueryObjectRequestedEvent>): void {
+    const {objects, executionContextId} = event.data;
+    const details = {
+      type: FrontendMessageType.QueryObjectResult,
+      parameters: [objects],
+      executionContextId,
+    };
+    const consoleMessage = new ConsoleMessage(
+        runtimeModel, Common.Console.FrontendMessageSource.ConsoleAPI, Protocol.Log.LogEntryLevel.Info, '', details);
+    this.addMessage(consoleMessage);
+  }
+
+  private clearIfNecessary(): void {
+    if (!Common.Settings.Settings.instance().moduleSetting('preserve-console-log').get()) {
+      this.clear();
+    }
+    ++this.#pageLoadSequenceNumber;
+  }
+
+  private primaryPageChanged(
+      event: Common.EventTarget.EventTargetEvent<{frame: ResourceTreeFrame, type: PrimaryPageChangeType}>): void {
+    if (Common.Settings.Settings.instance().moduleSetting('preserve-console-log').get()) {
+      const {frame} = event.data;
+      if (frame.backForwardCacheDetails.restoredFromCache) {
+        Common.Console.Console.instance().log(i18nString(UIStrings.bfcacheNavigation, {PH1: frame.url}));
+      } else {
+        Common.Console.Console.instance().log(i18nString(UIStrings.navigatedToS, {PH1: frame.url}));
+      }
+    }
+  }
+
+  private consoleProfileStarted(
+      cpuProfilerModel: CPUProfilerModel, event: Common.EventTarget.EventTargetEvent<EventData>): void {
+    const {data} = event;
+    this.addConsoleProfileMessage(
+        cpuProfilerModel, Protocol.Runtime.ConsoleAPICalledEventType.Profile, data.scriptLocation,
+        i18nString(UIStrings.profileSStarted, {PH1: data.title}));
+  }
+
+  private consoleProfileFinished(
+      cpuProfilerModel: CPUProfilerModel, event: Common.EventTarget.EventTargetEvent<EventData>): void {
+    const {data} = event;
+    this.addConsoleProfileMessage(
+        cpuProfilerModel, Protocol.Runtime.ConsoleAPICalledEventType.ProfileEnd, data.scriptLocation,
+        i18nString(UIStrings.profileSFinished, {PH1: data.title}));
+  }
+
+  private addConsoleProfileMessage(
+      cpuProfilerModel: CPUProfilerModel, type: MessageType, scriptLocation: Location, messageText: string): void {
+    const script = scriptLocation.script();
+    const callFrames = [{
+      functionName: '',
+      scriptId: scriptLocation.scriptId,
+      url: script ? script.contentURL() : '',
+      lineNumber: scriptLocation.lineNumber,
+      columnNumber: scriptLocation.columnNumber || 0,
+    }];
+    this.addMessage(new ConsoleMessage(
+        cpuProfilerModel.runtimeModel(), Common.Console.FrontendMessageSource.ConsoleAPI,
+        Protocol.Log.LogEntryLevel.Info, messageText, {type, stackTrace: {callFrames}}));
+  }
+
+  private incrementErrorWarningCount(msg: ConsoleMessage): void {
+    if (msg.source === Protocol.Log.LogEntrySource.Violation) {
+      this.#violations++;
+      return;
+    }
+    switch (msg.level) {
+      case Protocol.Log.LogEntryLevel.Warning:
+        this.#warnings++;
+        break;
+      case Protocol.Log.LogEntryLevel.Error:
+        this.#errors++;
+        break;
+    }
+  }
+
+  messages(): ConsoleMessage[] {
+    return this.#messages;
+  }
+
+  // messages[] are not ordered by timestamp.
+  static allMessagesUnordered(): ConsoleMessage[] {
+    const messages = [];
+    for (const target of TargetManager.instance().targets()) {
+      const targetMessages = target.model(ConsoleModel)?.messages() || [];
+      messages.push(...targetMessages);
+    }
+    return messages;
+  }
+
+  static requestClearMessages(): void {
+    for (const logModel of TargetManager.instance().models(LogModel)) {
+      logModel.requestClear();
+    }
+    for (const runtimeModel of TargetManager.instance().models(RuntimeModel)) {
+      runtimeModel.discardConsoleEntries();
+      // Runtime.discardConsoleEntries implies Runtime.releaseObjectGroup('console').
+      runtimeModel.releaseObjectGroup('live-expression');
+    }
+    for (const target of TargetManager.instance().targets()) {
+      target.model(ConsoleModel)?.clear();
+    }
+  }
+
+  private clear(): void {
+    this.#messages = [];
+    this.#messagesByTimestamp.clear();
+    this.#messageByExceptionId.clear();
+    this.#errors = 0;
+    this.#warnings = 0;
+    this.#violations = 0;
+    this.dispatchEventToListeners(Events.ConsoleCleared);
+  }
+
+  errors(): number {
+    return this.#errors;
+  }
+
+  static allErrors(): number {
+    let errors = 0;
+    for (const target of TargetManager.instance().targets()) {
+      errors += target.model(ConsoleModel)?.errors() || 0;
+    }
+    return errors;
+  }
+
+  warnings(): number {
+    return this.#warnings;
+  }
+
+  static allWarnings(): number {
+    let warnings = 0;
+    for (const target of TargetManager.instance().targets()) {
+      warnings += target.model(ConsoleModel)?.warnings() || 0;
+    }
+    return warnings;
+  }
+
+  violations(): number {
+    return this.#violations;
+  }
+
+  async saveToTempVariable(currentExecutionContext: ExecutionContext|null, remoteObject: RemoteObject|null):
+      Promise<void> {
+    if (!remoteObject || !currentExecutionContext) {
+      failedToSave(null);
+      return;
+    }
+    const executionContext = (currentExecutionContext);
+
+    const result = await executionContext.globalObject(/* objectGroup */ '', /* generatePreview */ false);
+    if ('error' in result || Boolean(result.exceptionDetails) || !result.object) {
+      failedToSave('object' in result && result.object || null);
+      return;
+    }
+
+    const globalObject = result.object;
+    const callFunctionResult =
+        await globalObject.callFunction(saveVariable, [RemoteObject.toCallArgument(remoteObject)]);
+    globalObject.release();
+    if (callFunctionResult.wasThrown || !callFunctionResult.object || callFunctionResult.object.type !== 'string') {
+      failedToSave(callFunctionResult.object || null);
+    } else {
+      const text = (callFunctionResult.object.value as string);
+      const message = this.addCommandMessage(executionContext, text);
+      void this.evaluateCommandInConsole(executionContext, message, text, /* useCommandLineAPI */ false);
+    }
+    if (callFunctionResult.object) {
+      callFunctionResult.object.release();
+    }
+
+    function saveVariable(this: Window, value: Protocol.Runtime.CallArgument): string {
+      const prefix = 'temp';
+      let index = 1;
+      while ((prefix + index) in this) {
+        ++index;
+      }
+      const name = prefix + index;
+      // @ts-expect-error Assignment to global object
+      this[name] = value;
+      return name;
+    }
+
+    function failedToSave(result: RemoteObject|null): void {
+      let message = i18nString(UIStrings.failedToSaveToTempVariable);
+      if (result) {
+        message = (message + ' ' + result.description as Common.UIString.LocalizedString);
+      }
+      Common.Console.Console.instance().error(message);
+    }
+  }
+}
+
+export enum Events {
+  /* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
+  ConsoleCleared = 'ConsoleCleared',
+  MessageAdded = 'MessageAdded',
+  MessageUpdated = 'MessageUpdated',
+  CommandEvaluated = 'CommandEvaluated',
+  /* eslint-enable @typescript-eslint/naming-convention */
+}
+
+export interface CommandEvaluatedEvent {
+  result: RemoteObject;
+  commandMessage: ConsoleMessage;
+  exceptionDetails?: Protocol.Runtime.ExceptionDetails|undefined;
+}
+
+export interface EventTypes {
+  [Events.ConsoleCleared]: void;
+  [Events.MessageAdded]: ConsoleMessage;
+  [Events.MessageUpdated]: ConsoleMessage;
+  [Events.CommandEvaluated]: CommandEvaluatedEvent;
+}
+
+export interface AffectedResources {
+  requestId?: Protocol.Network.RequestId;
+  issueId?: Protocol.Audits.IssueId;
+}
+
+function extractExceptionMetaData(metaData?: {
+  requestId?: Protocol.Network.RequestId,
+  issueId?: Protocol.Audits.IssueId,
+}): AffectedResources|undefined {
+  if (!metaData) {
+    return undefined;
+  }
+  return {requestId: metaData.requestId || undefined, issueId: metaData.issueId || undefined};
+}
+
+function areAffectedResourcesEquivalent(a?: AffectedResources, b?: AffectedResources): boolean {
+  // Not considering issueId, as that would prevent de-duplication of console #messages.
+  return a?.requestId === b?.requestId;
+}
+
+function areStackTracesEquivalent(
+    stackTrace1?: Protocol.Runtime.StackTrace, stackTrace2?: Protocol.Runtime.StackTrace): boolean {
+  if (!stackTrace1 !== !stackTrace2) {
+    return false;
+  }
+  if (!stackTrace1 || !stackTrace2) {
+    return true;
+  }
+  const callFrames1 = stackTrace1.callFrames;
+  const callFrames2 = stackTrace2.callFrames;
+  if (callFrames1.length !== callFrames2.length) {
+    return false;
+  }
+  for (let i = 0, n = callFrames1.length; i < n; ++i) {
+    if (callFrames1[i].scriptId !== callFrames2[i].scriptId ||
+        callFrames1[i].functionName !== callFrames2[i].functionName ||
+        callFrames1[i].lineNumber !== callFrames2[i].lineNumber ||
+        callFrames1[i].columnNumber !== callFrames2[i].columnNumber) {
+      return false;
+    }
+  }
+  return areStackTracesEquivalent(stackTrace1.parent, stackTrace2.parent);
+}
+
+export interface ConsoleMessageDetails {
+  type?: MessageType;
+  url?: Platform.DevToolsPath.UrlString;
+  line?: number;
+  column?: number;
+  parameters?: Array<string|RemoteObject|Protocol.Runtime.RemoteObject>;
+  stackTrace?: Protocol.Runtime.StackTrace;
+  timestamp?: number;
+  executionContextId?: number;
+  scriptId?: Protocol.Runtime.ScriptId;
+  workerId?: string;
+  context?: string;
+  affectedResources?: AffectedResources;
+  category?: Protocol.Log.LogEntryCategory;
+  isCookieReportIssue?: boolean;
+}
+
+export class ConsoleMessage {
+  readonly #runtimeModel: RuntimeModel|null;
+  source: MessageSource;
+  level: Protocol.Log.LogEntryLevel|null;
+  messageText: string;
+  readonly type: MessageType;
+  url: Platform.DevToolsPath.UrlString|undefined;
+  line: number;
+  column: number;
+  parameters: Array<string|RemoteObject|Protocol.Runtime.RemoteObject>|undefined;
+  stackTrace: Protocol.Runtime.StackTrace|undefined;
+  timestamp: number;
+  #executionContextId: number;
+  scriptId?: Protocol.Runtime.ScriptId;
+  workerId?: string;
+  context?: string;
+  #originatingConsoleMessage: ConsoleMessage|null = null;
+  #pageLoadSequenceNumber?: number = undefined;
+  #exceptionId?: number = undefined;
+  #affectedResources?: AffectedResources;
+  category?: Protocol.Log.LogEntryCategory;
+  isCookieReportIssue = false;
+
+  /**
+   * The parent frame of the `console.log` call of logpoints or conditional breakpoints
+   * if they called `console.*` explicitly. The parent frame is where V8 paused
+   * and consequently where the logpoint is set.
+   *
+   * Is `null` for page console.logs, commands, command results, etc.
+   */
+  readonly stackFrameWithBreakpoint: Protocol.Runtime.CallFrame|null = null;
+  readonly #originatingBreakpointType: BreakpointType|null = null;
+
+  constructor(
+      runtimeModel: RuntimeModel|null, source: MessageSource, level: Protocol.Log.LogEntryLevel|null,
+      messageText: string, details?: ConsoleMessageDetails) {
+    this.#runtimeModel = runtimeModel;
+    this.source = source;
+    this.level = (level);
+    this.messageText = messageText;
+    this.type = details?.type || Protocol.Runtime.ConsoleAPICalledEventType.Log;
+    this.url = details?.url;
+    this.line = details?.line || 0;
+    this.column = details?.column || 0;
+    this.parameters = details?.parameters;
+    this.stackTrace = details?.stackTrace;
+    this.timestamp = details?.timestamp || Date.now();
+    this.#executionContextId = details?.executionContextId || 0;
+    this.scriptId = details?.scriptId;
+    this.workerId = details?.workerId;
+    this.#affectedResources = details?.affectedResources;
+    this.category = details?.category;
+    this.isCookieReportIssue = Boolean(details?.isCookieReportIssue);
+
+    if (!this.#executionContextId && this.#runtimeModel) {
+      if (this.scriptId) {
+        this.#executionContextId = this.#runtimeModel.executionContextIdForScriptId(this.scriptId);
+      } else if (this.stackTrace) {
+        this.#executionContextId = this.#runtimeModel.executionContextForStackTrace(this.stackTrace);
+      }
+    }
+
+    if (details?.context) {
+      const match = details?.context.match(/[^#]*/);
+      this.context = match?.[0];
+    }
+
+    if (this.stackTrace) {
+      const {callFrame, type} = ConsoleMessage.#stackFrameWithBreakpoint(this.stackTrace);
+      this.stackFrameWithBreakpoint = callFrame;
+      this.#originatingBreakpointType = type;
+    }
+  }
+
+  getAffectedResources(): AffectedResources|undefined {
+    return this.#affectedResources;
+  }
+
+  setPageLoadSequenceNumber(pageLoadSequenceNumber: number): void {
+    this.#pageLoadSequenceNumber = pageLoadSequenceNumber;
+  }
+
+  static fromException(
+      runtimeModel: RuntimeModel, exceptionDetails: Protocol.Runtime.ExceptionDetails,
+      messageType?: Protocol.Runtime.ConsoleAPICalledEventType|FrontendMessageType, timestamp?: number,
+      forceUrl?: Platform.DevToolsPath.UrlString, affectedResources?: AffectedResources): ConsoleMessage {
+    const details = {
+      type: messageType,
+      url: forceUrl || exceptionDetails.url as Platform.DevToolsPath.UrlString,
+      line: exceptionDetails.lineNumber,
+      column: exceptionDetails.columnNumber,
+      parameters: exceptionDetails.exception ?
+          [RemoteObject.fromLocalObject(exceptionDetails.text), exceptionDetails.exception] :
+          undefined,
+      stackTrace: exceptionDetails.stackTrace,
+      timestamp,
+      executionContextId: exceptionDetails.executionContextId,
+      scriptId: exceptionDetails.scriptId,
+      affectedResources,
+    };
+    return new ConsoleMessage(
+        runtimeModel, Protocol.Log.LogEntrySource.Javascript, Protocol.Log.LogEntryLevel.Error,
+        RuntimeModel.simpleTextFromException(exceptionDetails), details);
+  }
+
+  runtimeModel(): RuntimeModel|null {
+    return this.#runtimeModel;
+  }
+
+  target(): Target|null {
+    return this.#runtimeModel ? this.#runtimeModel.target() : null;
+  }
+
+  setOriginatingMessage(originatingMessage: ConsoleMessage): void {
+    this.#originatingConsoleMessage = originatingMessage;
+    this.#executionContextId = originatingMessage.#executionContextId;
+  }
+
+  originatingMessage(): ConsoleMessage|null {
+    return this.#originatingConsoleMessage;
+  }
+
+  setExecutionContextId(executionContextId: number): void {
+    this.#executionContextId = executionContextId;
+  }
+
+  getExecutionContextId(): number {
+    return this.#executionContextId;
+  }
+
+  getExceptionId(): number|undefined {
+    return this.#exceptionId;
+  }
+
+  setExceptionId(exceptionId: number): void {
+    this.#exceptionId = exceptionId;
+  }
+
+  isGroupMessage(): boolean {
+    return this.type === Protocol.Runtime.ConsoleAPICalledEventType.StartGroup ||
+        this.type === Protocol.Runtime.ConsoleAPICalledEventType.StartGroupCollapsed ||
+        this.type === Protocol.Runtime.ConsoleAPICalledEventType.EndGroup;
+  }
+
+  isGroupStartMessage(): boolean {
+    return this.type === Protocol.Runtime.ConsoleAPICalledEventType.StartGroup ||
+        this.type === Protocol.Runtime.ConsoleAPICalledEventType.StartGroupCollapsed;
+  }
+
+  isErrorOrWarning(): boolean {
+    return (this.level === Protocol.Log.LogEntryLevel.Warning || this.level === Protocol.Log.LogEntryLevel.Error);
+  }
+
+  isGroupable(): boolean {
+    const isUngroupableError = this.level === Protocol.Log.LogEntryLevel.Error &&
+        (this.source === Protocol.Log.LogEntrySource.Javascript || this.source === Protocol.Log.LogEntrySource.Network);
+    return (
+        this.source !== Common.Console.FrontendMessageSource.ConsoleAPI && this.type !== FrontendMessageType.Command &&
+        this.type !== FrontendMessageType.Result && this.type !== FrontendMessageType.System && !isUngroupableError);
+  }
+
+  groupCategoryKey(): string {
+    return [this.source, this.level, this.type, this.#pageLoadSequenceNumber].join(':');
+  }
+
+  isEqual(msg: ConsoleMessage|null): boolean {
+    if (!msg) {
+      return false;
+    }
+
+    if (this.parameters) {
+      if (!msg.parameters || this.parameters.length !== msg.parameters.length) {
+        return false;
+      }
+
+      for (let i = 0; i < msg.parameters.length; ++i) {
+        const msgParam = msg.parameters[i];
+        const param = this.parameters[i];
+        if (typeof msgParam === 'string' || typeof param === 'string') {
+          // TODO(chromium:1136435): Remove this case.
+          return false;
+        }
+        if (msgParam.type === 'object' && msgParam.subtype !== 'error') {
+          if (!msgParam.objectId || msgParam.objectId !== param.objectId || msg.timestamp !== this.timestamp) {
+            return false;
+          }
+        }
+        if (param.type !== msgParam.type || param.value !== msgParam.value ||
+            param.description !== msgParam.description) {
+          return false;
+        }
+      }
+    }
+
+    return (this.runtimeModel() === msg.runtimeModel()) && (this.source === msg.source) && (this.type === msg.type) &&
+        (this.level === msg.level) && (this.line === msg.line) && (this.url === msg.url) &&
+        (this.scriptId === msg.scriptId) && (this.messageText === msg.messageText) &&
+        (this.#executionContextId === msg.#executionContextId) &&
+        areAffectedResourcesEquivalent(this.#affectedResources, msg.#affectedResources) &&
+        areStackTracesEquivalent(this.stackTrace, msg.stackTrace);
+  }
+
+  get originatesFromLogpoint(): boolean {
+    return this.#originatingBreakpointType === BreakpointType.LOGPOINT;
+  }
+
+  /** @returns true, iff this was a console.* call in a conditional breakpoint */
+  get originatesFromConditionalBreakpoint(): boolean {
+    return this.#originatingBreakpointType === BreakpointType.CONDITIONAL_BREAKPOINT;
+  }
+
+  static #stackFrameWithBreakpoint({callFrames}: Protocol.Runtime.StackTrace):
+      {callFrame: Protocol.Runtime.CallFrame|null, type: BreakpointType|null} {
+    // Note that breakpoint condition code could in theory call into user JS and back into
+    // "condition-defined" functions. This means that the top-most
+    // stack frame is not necessarily the `console.log` call, but there could be other things
+    // on top. We want the LAST marker frame in the stack.
+    // We search FROM THE TOP for the last marked stack frame and
+    // return it's parent (successor).
+    const markerSourceUrls = [COND_BREAKPOINT_SOURCE_URL, LOGPOINT_SOURCE_URL];
+    const lastBreakpointFrameIndex = callFrames.findLastIndex(({url}) => markerSourceUrls.includes(url));
+    if (lastBreakpointFrameIndex === -1 || lastBreakpointFrameIndex === callFrames.length - 1) {
+      // We either didn't find any breakpoint or we didn't capture enough stack
+      // frames and the breakpoint condition is the bottom-most frame.
+      return {callFrame: null, type: null};
+    }
+
+    const type = callFrames[lastBreakpointFrameIndex].url === LOGPOINT_SOURCE_URL ?
+        BreakpointType.LOGPOINT :
+        BreakpointType.CONDITIONAL_BREAKPOINT;
+    return {callFrame: callFrames[lastBreakpointFrameIndex + 1], type};
+  }
+}
+
+SDKModel.register(ConsoleModel, {capabilities: Capability.JS, autostart: true});
+
+export type MessageSource = Protocol.Log.LogEntrySource|Common.Console.FrontendMessageSource;
+export type MessageLevel = Protocol.Log.LogEntryLevel;
+export type MessageType = Protocol.Runtime.ConsoleAPICalledEventType|FrontendMessageType;
+
+export const MessageSourceDisplayName = new Map<MessageSource, string>(([
+  [Protocol.Log.LogEntrySource.XML, 'xml'],
+  [Protocol.Log.LogEntrySource.Javascript, 'javascript'],
+  [Protocol.Log.LogEntrySource.Network, 'network'],
+  [Common.Console.FrontendMessageSource.ConsoleAPI, 'console-api'],
+  [Protocol.Log.LogEntrySource.Storage, 'storage'],
+  [Protocol.Log.LogEntrySource.Appcache, 'appcache'],
+  [Protocol.Log.LogEntrySource.Rendering, 'rendering'],
+  [Common.Console.FrontendMessageSource.CSS, 'css'],
+  [Protocol.Log.LogEntrySource.Security, 'security'],
+  [Protocol.Log.LogEntrySource.Deprecation, 'deprecation'],
+  [Protocol.Log.LogEntrySource.Worker, 'worker'],
+  [Protocol.Log.LogEntrySource.Violation, 'violation'],
+  [Protocol.Log.LogEntrySource.Intervention, 'intervention'],
+  [Protocol.Log.LogEntrySource.Recommendation, 'recommendation'],
+  [Protocol.Log.LogEntrySource.Other, 'other'],
+  [Common.Console.FrontendMessageSource.ISSUE_PANEL, 'issue-panel'],
+]));