chrome-devtools-frontend 1.0.1535712 → 1.0.1537268

package/docs/contributing/issues.md

@@ -48,10 +48,11 @@ to Markdown (with a preview below the text input box).
 1.  Replace `<from chrome://version/>` and `<OS version>` with the relevant
     version information.
 1.  Outline exact steps to reproduce the problem. Make sure to provide steps
-    that are easy and accessible. Ideally create a minified test case on
-    [glitch.com](http://glitch.com) or [GitHub](http://github.com). Also
-    make sure to include screenshots and videos that help us to reproduce
-    and understand the problem you are facing.
+    that are easy and accessible. Ideally create a [minimal, reproducible
+    example](https://stackoverflow.com/help/minimal-reproducible-example), e.g.
+    on [codepen.io](https://codepen.io), [jsbin.com](https://jsbin.com) or
+    [GitHub](https://github.com). Also make sure to include screenshots and
+    videos that help us to reproduce and understand the problem you are facing.
 
 ## Overview
 
@@ -173,25 +174,21 @@ DevTools we want to
 1. reduce the number of regressions that ship to the (Chrome) Stable channel, and
 2. reduce the number of bugs overall.
 
-The following SLOs (Service Level Objectives) apply to issues of type Bug,
-Vulnerability, and Privacy Issue. other types of issues such as Feature Request
-or Task are out of scope for SLOs (with the notable exception of Postmortem action
-items, where Chrome also enforces SLOs for non-bug issues). We also explicitly
-restrict these SLOs to bugs in [crbug], and are not concerned with bugs that are
-tracked in other places such as GitHub. Below is a high level summary of our SLOs
-(Googlers can check the [Chrome DevTools SLO Policy] and [Chrome SLO Policy] for
-more details):
+The following SLOs (Service Level Objectives) apply to issues of type "Bug",
+"Vulnerability", and "Privacy Issue". other types of issues such as "Feature
+Request" or "Task" are out of scope for SLOs (with the notable exception of
+Postmortem action items, where Chrome also enforces SLOs for non-bug issues).
+We also explicitly restrict these SLOs to bugs in [crbug], and are not concerned
+with bugs that are tracked in other places such as GitHub. Below is a high level
+summary of our SLOs (Googlers can check the [Chrome SLO Policy] for details):
 
 |      | Assignment     | Response           | Closure
 | ---- | -------------- | ------------------ | --------
 | `P0` | 1 business day | Every business day | 1 week
 | `P1` | 1 week         | 1 week             | 4 weeks
-| `P2` | 2 months       | -                  | 6 months
-| `P3` | 1 year         | -                  | -
 
-The first two rows are identical to [go/chrome-slo], with the last two rows being
-specific to Chrome DevTools. [crbug] provides a **Nearest SLO** column that
-surfaces SLO violations easily:
+These are identical to [go/chrome-slo]. [crbug] provides a **Nearest SLO**
+column that surfaces SLO violations easily:
 
 ![Nearest SLO in crbug](./images/issues-nearestslo.png "Nearest SLO in crbug")
 
@@ -200,7 +197,7 @@ surfaces SLO violations easily:
 
 ### Release Blocking Issues
 
-In accordance with go/chrome-slo there are special SLOs for issues that are
+In compliance with [go/chrome-slo] there are special SLOs for issues that are
 severe enough to block a release shipping to users (see [go/chrome-release-slos]).
 They apply to bug types in the same way as the above SLOs.
 
@@ -237,12 +234,11 @@ refreshed every 2-4 hours, to see SLO compliance for a given lead.
   [How to file a good browser bug]: https://web.dev/articles/how-to-file-a-good-bug
   [Open Chromium DevTools Bugs]: https://issues.chromium.org/issues?q=status:open%20componentid:1457055%2B%20type:bug
   [goo.gle/devtools-bug]: https://goo.gle/devtools-bug
-  [Chrome DevTools SLO Policy]: https://b.corp.google.com/slos/61348
-  [Chrome SLO Policy]: https://b.corp.google.com/slos/1834
+  [Chrome SLO Policy]: http://b/slos/1834
   [go/chrome-slo]: http://go/chrome-slo
   [go/chrome-release-slos]: http://go/chrome-release-slos
   [go/chrome-tooling/project-management]: http://go/chrome-tooling/project-management
-  [Buganizer SLO Compliance]: go/b-slo-compliance
+  [Buganizer SLO Compliance]: http://go/b-slo-compliance
   [TaskFlow]: http://go/chrome-devtools:taskflow
   [TaskFlow Inbox]: http://go/chrome-devtools:taskflow/inbox
   [Chromium>Platform>DevTools]: https://issues.chromium.org/components/1457055

package/front_end/core/common/Console.ts

@@ -8,14 +8,7 @@ import {reveal} from './Revealer.js';
 let consoleInstance: Console|undefined;
 
 export class Console extends ObjectWrapper<EventTypes> {
-  readonly #messages: Message[];
-  /**
-   * Instantiable via the instance() factory below.
-   */
-  constructor() {
-    super();
-    this.#messages = [];
-  }
+  readonly #messages: Message[] = [];
 
   static instance(opts?: {forceNew: boolean}): Console {
     if (!consoleInstance || opts?.forceNew) {

package/front_end/core/common/ParsedURL.ts

@@ -57,33 +57,23 @@ type BrandedPathString =
     Platform.DevToolsPath.UrlString|Platform.DevToolsPath.RawPathString|Platform.DevToolsPath.EncodedPathString;
 
 export class ParsedURL {
-  isValid: boolean;
+  isValid = false;
   url: string;
-  scheme: string;
-  user: string;
-  host: string;
-  port: string;
-  path: string;
-  queryParams: string;
-  fragment: string;
-  folderPathComponents: string;
-  lastPathComponent: string;
+  scheme = '';
+  user = '';
+  host = '';
+  port = '';
+  path = '';
+  queryParams = '';
+  fragment = '';
+  folderPathComponents = '';
+  lastPathComponent = '';
   readonly blobInnerScheme: string|undefined;
   #displayName?: string;
   #dataURLDisplayName?: string;
 
   constructor(url: string) {
-    this.isValid = false;
     this.url = url;
-    this.scheme = '';
-    this.user = '';
-    this.host = '';
-    this.port = '';
-    this.path = '';
-    this.queryParams = '';
-    this.fragment = '';
-    this.folderPathComponents = '';
-    this.lastPathComponent = '';
 
     const isBlobUrl = this.url.startsWith('blob:');
     const urlToMatch = isBlobUrl ? url.substring(5) : url;

package/front_end/core/common/SegmentedRange.ts

@@ -24,11 +24,10 @@ export class Segment<T> {
 }
 
 export class SegmentedRange<T> {
-  #segments: Array<Segment<T>>;
+  #segments: Array<Segment<T>> = [];
   readonly #mergeCallback: ((arg0: Segment<T>, arg1: Segment<T>) => Segment<T>| null)|undefined;
 
   constructor(mergeCallback?: ((arg0: Segment<T>, arg1: Segment<T>) => Segment<T>| null)) {
-    this.#segments = [];
     this.#mergeCallback = mergeCallback;
   }
 

package/front_end/core/common/StringOutputStream.ts

@@ -8,10 +8,7 @@ export interface OutputStream {
 }
 
 export class StringOutputStream implements OutputStream {
-  #data: string;
-  constructor() {
-    this.#data = '';
-  }
+  #data = '';
 
   async write(chunk: string): Promise<void> {
     this.#data += chunk;

package/front_end/core/host/AidaClient.ts

@@ -5,6 +5,7 @@
 import * as Common from '../common/common.js';
 import * as Root from '../root/root.js';
 
+import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
 import {InspectorFrontendHostInstance} from './InspectorFrontendHost.js';
 import type {AidaClientResult, AidaCodeCompleteResult, SyncInformation} from './InspectorFrontendHostAPI.js';
 import {bindOutputStream} from './ResourceLoader.js';
@@ -213,6 +214,24 @@ export interface CompleteCodeOptions {
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
+/* eslint-disable @typescript-eslint/naming-convention */
+export interface GenerateCodeOptions {
+  temperature?: number;
+  model_id?: string;
+  inference_language?: AidaInferenceLanguage;
+  expect_code_output?: boolean;
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
+/* eslint-disable @typescript-eslint/naming-convention */
+export interface ContextFile {
+  path: string;
+  full_content: string;
+  selected_content?: string;
+  programming_language: AidaInferenceLanguage;
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
 export enum EditType {
   // Unknown edit type
   EDIT_TYPE_UNSPECIFIED = 0,
@@ -252,6 +271,12 @@ export enum Reason {
 }
 
 /* eslint-disable @typescript-eslint/naming-convention */
+export interface AdditionalFile {
+  path: string;
+  content: string;
+  included_reason: Reason;
+}
+
 export interface CompletionRequest {
   client: string;
   prefix: string;
@@ -259,11 +284,28 @@ export interface CompletionRequest {
   options?: CompleteCodeOptions;
   metadata: RequestMetadata;
   last_user_action?: EditType;
-  additional_files?: Array<{
-    path: string,
-    content: string,
-    included_reason: Reason,
-  }>;
+  additional_files?: AdditionalFile[];
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
+export enum UseCase {
+  // Unspecified usecase.
+  USE_CASE_UNSPECIFIED = 0,
+
+  // Code generation use case is expected to generate code from scratch
+  CODE_GENERATION = 1,
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+export interface GenerateCodeRequest {
+  client: string;
+  preamble: string;
+  current_message: Content;
+  options?: GenerateCodeOptions;
+  context_files?: ContextFile[];
+  use_case: UseCase;
+  metadata: RequestMetadata;
+  client_feature?: ClientFeature;
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
@@ -363,6 +405,11 @@ export interface CompletionResponse {
   metadata: ResponseMetadata;
 }
 
+export interface GenerateCodeResponse {
+  samples: GenerationSample[];
+  metadata: ResponseMetadata;
+}
+
 export interface GenerationSample {
   generationString: string;
   score: number;
@@ -416,6 +463,7 @@ const AidaLanguageToMarkdown: Record<AidaInferenceLanguage, string> = {
 };
 
 export const CLIENT_NAME = 'CHROME_DEVTOOLS';
+export const SERVICE_NAME = 'aidaService';
 
 const CODE_CHUNK_SEPARATOR = (lang = ''): string => ('\n`````' + lang + '\n');
 
@@ -657,6 +705,17 @@ export class AidaClient {
 
     return {generatedSamples, metadata};
   }
+
+  async generateCode(request: GenerateCodeRequest): Promise<GenerateCodeResponse|null> {
+    const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateCodeResponse>({
+      service: SERVICE_NAME,
+      path: '/v1/aida:generateCode',
+      method: 'POST',
+      body: JSON.stringify(request),
+    });
+
+    return response;
+  }
 }
 
 export function convertToUserTierEnum(userTier: string|undefined): UserTier {

package/front_end/core/host/DispatchHttpRequestClient.ts

@@ -0,0 +1,62 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import {InspectorFrontendHostInstance} from './InspectorFrontendHost.js';
+import type {DispatchHttpRequestRequest, DispatchHttpRequestResult} from './InspectorFrontendHostAPI.js';
+
+export enum ErrorType {
+  HTTP_RESPONSE_UNAVAILABLE = 'HTTP_RESPONSE_UNAVAILABLE',
+  NOT_FOUND = 'NOT_FOUND',
+}
+
+export class DispatchHttpRequestError extends Error {
+  constructor(readonly type: ErrorType, options?: ErrorOptions) {
+    super(undefined, options);
+  }
+}
+
+export async function makeHttpRequest<R>(request: DispatchHttpRequestRequest): Promise<R> {
+  const response = await new Promise<DispatchHttpRequestResult>(resolve => {
+    InspectorFrontendHostInstance.dispatchHttpRequest(request, resolve);
+  });
+
+  debugLog({request, response});
+  if (response.statusCode === 404) {
+    throw new DispatchHttpRequestError(ErrorType.NOT_FOUND);
+  }
+
+  if ('response' in response && response.statusCode === 200) {
+    try {
+      return JSON.parse(response.response) as R;
+    } catch (err) {
+      throw new DispatchHttpRequestError(ErrorType.HTTP_RESPONSE_UNAVAILABLE, {cause: err});
+    }
+  }
+
+  throw new DispatchHttpRequestError(ErrorType.HTTP_RESPONSE_UNAVAILABLE);
+}
+
+function isDebugMode(): boolean {
+  return Boolean(localStorage.getItem('debugDispatchHttpRequestEnabled'));
+}
+
+function debugLog(...log: unknown[]): void {
+  if (!isDebugMode()) {
+    return;
+  }
+
+  // eslint-disable-next-line no-console
+  console.log('debugLog', ...log);
+}
+
+function setDebugDispatchHttpRequestEnabled(enabled: boolean): void {
+  if (enabled) {
+    localStorage.setItem('debugDispatchHttpRequestEnabled', 'true');
+  } else {
+    localStorage.removeItem('debugDispatchHttpRequestEnabled');
+  }
+}
+
+// @ts-expect-error
+globalThis.setDebugDispatchHttpRequestEnabled = setDebugDispatchHttpRequestEnabled;

package/front_end/core/host/GdpClient.ts

@@ -4,8 +4,8 @@
 
 import * as Root from '../root/root.js';
 
-import {InspectorFrontendHostInstance} from './InspectorFrontendHost.js';
-import type {DispatchHttpRequestRequest, DispatchHttpRequestResult} from './InspectorFrontendHostAPI.js';
+import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
+import type {DispatchHttpRequestRequest} from './InspectorFrontendHostAPI.js';
 
 export enum SubscriptionStatus {
   ENABLED = 'SUBSCRIPTION_STATE_ENABLED',
@@ -73,17 +73,6 @@ export interface GetProfileResponse {
   isEligible: boolean;
 }
 
-export enum GdpErrorType {
-  HTTP_RESPONSE_UNAVAILABLE = 'HTTP_RESPONSE_UNAVAILABLE',
-  NOT_FOUND = 'NOT_FOUND',
-}
-
-class GdpError extends Error {
-  constructor(readonly type: GdpErrorType, options?: ErrorOptions) {
-    super(undefined, options);
-  }
-}
-
 /**
  * The `batchGet` awards endpoint returns badge names with an
  * obfuscated user ID (e.g., `profiles/12345/awards/badge-name`).
@@ -99,27 +88,12 @@ export const GOOGLE_DEVELOPER_PROGRAM_PROFILE_LINK = 'https://developers.google.
 
 async function makeHttpRequest<R>(request: DispatchHttpRequestRequest): Promise<R> {
   if (!isGdpProfilesAvailable()) {
-    throw new GdpError(GdpErrorType.HTTP_RESPONSE_UNAVAILABLE);
-  }
-
-  const response = await new Promise<DispatchHttpRequestResult>(resolve => {
-    InspectorFrontendHostInstance.dispatchHttpRequest(request, resolve);
-  });
-
-  debugLog({request, response});
-  if (response.statusCode === 404) {
-    throw new GdpError(GdpErrorType.NOT_FOUND);
-  }
-
-  if ('response' in response && response.statusCode === 200) {
-    try {
-      return JSON.parse(response.response) as R;
-    } catch (err) {
-      throw new GdpError(GdpErrorType.HTTP_RESPONSE_UNAVAILABLE, {cause: err});
-    }
+    throw new DispatchHttpRequestClient.DispatchHttpRequestError(
+        DispatchHttpRequestClient.ErrorType.HTTP_RESPONSE_UNAVAILABLE);
   }
 
-  throw new GdpError(GdpErrorType.HTTP_RESPONSE_UNAVAILABLE);
+  const response = await DispatchHttpRequestClient.makeHttpRequest(request) as R;
+  return response;
 }
 
 const SERVICE_NAME = 'gdpService';
@@ -158,7 +132,8 @@ export class GdpClient {
         isEligible: true,
       };
     } catch (err: unknown) {
-      if (err instanceof GdpError && err.type === GdpErrorType.HTTP_RESPONSE_UNAVAILABLE) {
+      if (err instanceof DispatchHttpRequestClient.DispatchHttpRequestError &&
+          err.type === DispatchHttpRequestClient.ErrorType.HTTP_RESPONSE_UNAVAILABLE) {
         return null;
       }
     }
@@ -265,27 +240,6 @@ export class GdpClient {
   }
 }
 
-function isDebugMode(): boolean {
-  return Boolean(localStorage.getItem('debugGdpIntegrationEnabled'));
-}
-
-function debugLog(...log: unknown[]): void {
-  if (!isDebugMode()) {
-    return;
-  }
-
-  // eslint-disable-next-line no-console
-  console.log('debugLog', ...log);
-}
-
-function setDebugGdpIntegrationEnabled(enabled: boolean): void {
-  if (enabled) {
-    localStorage.setItem('debugGdpIntegrationEnabled', 'true');
-  } else {
-    localStorage.removeItem('debugGdpIntegrationEnabled');
-  }
-}
-
 export function isGdpProfilesAvailable(): boolean {
   const isBaseFeatureEnabled = Boolean(Root.Runtime.hostConfig.devToolsGdpProfiles?.enabled);
   const isBrandedBuild = Boolean(Root.Runtime.hostConfig.devToolsGdpProfilesAvailability?.enabled);
@@ -311,6 +265,3 @@ export function isBadgesEnabled(): boolean {
 export function isStarterBadgeEnabled(): boolean {
   return Boolean(Root.Runtime.hostConfig.devToolsGdpProfiles?.starterBadgeEnabled);
 }
-
-// @ts-expect-error
-globalThis.setDebugGdpIntegrationEnabled = setDebugGdpIntegrationEnabled;

package/front_end/core/host/host.ts

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import * as AidaClient from './AidaClient.js';
+import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
 import * as GdpClient from './GdpClient.js';
 import * as InspectorFrontendHost from './InspectorFrontendHost.js';
 import * as InspectorFrontendHostAPI from './InspectorFrontendHostAPI.js';
@@ -12,6 +13,7 @@ import * as UserMetrics from './UserMetrics.js';
 
 export {
   AidaClient,
+  DispatchHttpRequestClient,
   GdpClient,
   InspectorFrontendHost,
   InspectorFrontendHostAPI,

package/front_end/core/i18n/i18nImpl.ts

@@ -1,7 +1,6 @@
 // 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.
-/* eslint-disable @devtools/no-imperative-dom-api */
 
 import * as I18n from '../../third_party/i18n/i18n.js';
 import type * as Platform from '../platform/platform.js';
@@ -117,29 +116,6 @@ export function registerUIStrings(
   return i18nInstance.registerFileStrings(path, stringStructure);
 }
 
-/**
- * Returns a span element that may contains other DOM element as placeholders
- */
-export function getFormatLocalizedString(
-    registeredStrings: I18n.LocalizedStringSet.RegisteredFileStrings, stringId: string,
-    placeholders: Record<string, Object>): HTMLSpanElement {
-  const formatter =
-      registeredStrings.getLocalizedStringSetFor(DevToolsLocale.instance().locale).getMessageFormatterFor(stringId);
-
-  const element = document.createElement('span');
-  for (const icuElement of formatter.getAst()) {
-    if (icuElement.type === /* argumentElement */ 1) {
-      const placeholderValue = placeholders[icuElement.value];
-      if (placeholderValue) {
-        element.append(placeholderValue as Node | string);
-      }
-    } else if ('value' in icuElement) {
-      element.append(String(icuElement.value));
-    }
-  }
-  return element;
-}
-
 export function serializeUIString(string: string, values: Record<string, Object> = {}): string {
   const serializedMessage = {string, values};
   return JSON.stringify(serializedMessage);

package/front_end/core/protocol_client/CDPConnection.ts

@@ -41,17 +41,19 @@ export const enum CDPErrorStatus {
   SESSION_NOT_FOUND = SERVER_ERROR - 1,
 }
 
-export interface CDPError extends CDPBaseMessage {
+export interface CDPError {
+  code: CDPErrorStatus;
+  message: string;
+  data?: string;
+}
+
+export interface CDPErrorMessage extends CDPBaseMessage {
   id?: number;
-  error: {
-    code: CDPErrorStatus,
-    message: string,
-    data?: string,
-  };
+  error: CDPError;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type CDPMessage = CDPCommandRequest<any>|CDPCommandResponse<any>|CDPEvent<any>|CDPError;
+export type CDPMessage = CDPCommandRequest<any>|CDPCommandResponse<any>|CDPEvent<any>|CDPErrorMessage;
 
 /**
  * Allows the sending and receiving of CDP commands and the notification of CDP events to observers.
@@ -62,7 +64,7 @@ export type CDPMessage = CDPCommandRequest<any>|CDPCommandResponse<any>|CDPEvent
  */
 export interface CDPConnection {
   send<T extends keyof ProtocolMapping.Commands>(method: T, params: CommandParams<T>, sessionId: string|undefined):
-      Promise<CommandResult<T>|{getError(): string}>;
+      Promise<{result: CommandResult<T>}|{error: CDPError}>;
 
   observe(observer: CDPConnectionObserver): void;
   unobserve(observer: CDPConnectionObserver): void;

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -67,9 +67,13 @@ interface CommandParameter {
 }
 
 type Callback = (error: MessageError|null, arg1: Object|null) => void;
+interface ResponseWithError {
+  error: MessageError|null;
+  result: Object|null;
+}
 
 interface CallbackWithDebugInfo {
-  callback: Callback;
+  resolve: (response: ResponseWithError) => void;
   method: string;
 }
 
@@ -241,8 +245,15 @@ export class SessionRouter {
     if (!session) {
       return;
     }
-    for (const callback of session.callbacks.values()) {
-      SessionRouter.dispatchUnregisterSessionError(callback);
+    for (const {resolve, method} of session.callbacks.values()) {
+      resolve({
+        result: null,
+        error: {
+          message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
+          code: ConnectionClosedErrorCode,
+          data: null,
+        }
+      });
     }
     this.#sessions.delete(sessionId);
   }
@@ -255,7 +266,8 @@ export class SessionRouter {
     return this.#connection;
   }
 
-  sendMessage(sessionId: string, domain: string, method: QualifiedName, params: Object|null, callback: Callback): void {
+  sendMessage(sessionId: string, domain: string, method: QualifiedName, params: Object|null):
+      Promise<ResponseWithError> {
     const messageId = this.nextMessageId();
     const messageObject: Message = {
       id: messageId,
@@ -285,16 +297,19 @@ export class SessionRouter {
 
     const session = this.#sessions.get(sessionId);
     if (!session) {
-      return;
+      return Promise.resolve({error: null, result: null});
     }
-    session.callbacks.set(messageId, {callback, method});
-    this.#connection.sendRawMessage(JSON.stringify(messageObject));
+
+    return new Promise(resolve => {
+      session.callbacks.set(messageId, {resolve, method});
+      this.#connection.sendRawMessage(JSON.stringify(messageObject));
+    });
   }
 
   private sendRawMessageForTesting(method: QualifiedName, params: Object|null, callback: Callback|null, sessionId = ''):
       void {
     const domain = method.split('.')[0];
-    this.sendMessage(sessionId, domain, method, params, callback || (() => {}));
+    void this.sendMessage(sessionId, domain, method, params).then(({error, result}) => callback?.(error, result));
   }
 
   private onMessage(message: string|Object): void {
@@ -357,7 +372,7 @@ export class SessionRouter {
         return;
       }
 
-      callback.callback(messageObject.error || null, messageObject.result || null);
+      callback.resolve({error: messageObject.error || null, result: messageObject.result || null});
       --this.#pendingResponsesCount;
       this.#pendingLongPollingMessageIds.delete(messageObject.id);
 
@@ -403,24 +418,6 @@ export class SessionRouter {
       }
     }
   }
-
-  static dispatchConnectionError(callback: Callback, method: string): void {
-    const error = {
-      message: `Connection is closed, can\'t dispatch pending call to ${method}`,
-      code: ConnectionClosedErrorCode,
-      data: null,
-    };
-    window.setTimeout(() => callback(error, null), 0);
-  }
-
-  static dispatchUnregisterSessionError({callback, method}: CallbackWithDebugInfo): void {
-    const error = {
-      message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
-      code: ConnectionClosedErrorCode,
-      data: null,
-    };
-    window.setTimeout(() => callback(error, null), 0);
-  }
 }
 
 /**
@@ -878,23 +875,20 @@ class AgentPrototype {
   }
 
   private invoke(method: QualifiedName, request: Object|null): Promise<Protocol.ProtocolResponseWithError> {
-    return new Promise(fulfill => {
-      const callback: Callback = (error: MessageError|undefined|null, result: Object|null): void => {
-        if (error && !test.suppressRequestErrors && error.code !== DevToolsStubErrorCode &&
-            error.code !== GenericErrorCode && error.code !== ConnectionClosedErrorCode) {
-          console.error('Request ' + method + ' failed. ' + JSON.stringify(error));
-        }
-
-        const errorMessage = error?.message;
-        fulfill({...result, getError: () => errorMessage});
-      };
+    const router = this.target.router();
+    if (!router) {
+      return Promise.resolve(
+          {result: null, getError: () => `Connection is closed, can\'t dispatch pending call to ${method}`});
+    }
 
-      const router = this.target.router();
-      if (!router) {
-        SessionRouter.dispatchConnectionError(callback, method);
-      } else {
-        router.sendMessage(this.target.sessionId, this.domain, method, request, callback);
+    return router.sendMessage(this.target.sessionId, this.domain, method, request).then(({error, result}) => {
+      if (error && !test.suppressRequestErrors && error.code !== DevToolsStubErrorCode &&
+          error.code !== GenericErrorCode && error.code !== ConnectionClosedErrorCode) {
+        console.error('Request ' + method + ' failed. ' + JSON.stringify(error));
       }
+
+      const errorMessage = error?.message;
+      return {...result, getError: () => errorMessage};
     });
   }
 }