chrome-devtools-frontend 1.0.1604514 → 1.0.1605219

package/AUTHORS

@@ -58,6 +58,7 @@ Jithil p Ponnan <jithil.p@gmail.com>
 Juba Borgohain <chromiumjuba@gmail.com>
 Julian Geppert <spctstr@gmail.com>
 Junseo Yoo <joon.yoo181@berkeley.edu>
+Kanishk Ranjan <kanishkranjan17@gmail.com>
 Karntino Areros <karntino.c.areros@gmail.com>
 Kohei Ueno <kohei.ueno119@gmail.com>
 Krishnal Ciccolella <ciccolella.krishnal@gmail.com>

package/front_end/Tests.js

@@ -1086,20 +1086,36 @@
     this.takeControl({slownessFactor: 10});
   };
 
-  TestSuite.prototype.waitForTestResultsAsMessage = function() {
-    const onMessage = event => {
-      if (!event.data.testOutput) {
-        return;
-      }
-      top.removeEventListener('message', onMessage);
+  const earlyTestResults = [];
+  let testResultsWaiter = null;
+
+  top.addEventListener('message', event => {
+    if (event.data && event.data.testOutput) {
       const text = event.data.testOutput;
+      if (testResultsWaiter) {
+        testResultsWaiter(text);
+      } else {
+        earlyTestResults.push(text);
+      }
+    }
+  });
+
+  TestSuite.prototype.waitForTestResultsAsMessage = function() {
+    const handleMessage = text => {
+      testResultsWaiter = null;
       if (text === 'PASS') {
         this.releaseControl();
       } else {
         this.fail(text);
       }
     };
-    top.addEventListener('message', onMessage);
+
+    if (earlyTestResults.length) {
+      handleMessage(earlyTestResults.shift());
+      return;
+    }
+
+    testResultsWaiter = handleMessage;
     this.takeControl();
   };
 

package/front_end/core/host/AidaClient.ts

@@ -7,12 +7,14 @@ import * as Root from '../root/root.js';
 
 import {
   AidaAccessPreconditions,
+  type AidaChunkResponse,
   type AidaFunctionCallResponse,
   AidaInferenceLanguage,
   type AidaRegisterClientEvent,
   ClientFeature,
   type CompletionRequest,
   type CompletionResponse,
+  debugLog,
   type DoConversationRequest,
   type DoConversationResponse,
   FunctionalityType,
@@ -24,7 +26,10 @@ import {
   Role,
   UserTier,
 } from './AidaClientTypes.js';
+import {gcaChunkResponseToAidaChunkResponse} from './AidaGcaTranslation.js';
 import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
+import * as GcaClient from './GcaClient.js';
+import type {GenerateContentResponse} from './GcaTypes.js';
 import {InspectorFrontendHostInstance} from './InspectorFrontendHost.js';
 import type {AidaClientResult, AidaCodeCompleteResult, SyncInformation} from './InspectorFrontendHostAPI.js';
 import {bindOutputStream} from './ResourceLoader.js';
@@ -58,7 +63,17 @@ const AidaLanguageToMarkdown: Record<AidaInferenceLanguage, string> = {
 export class AidaAbortError extends Error {}
 export class AidaBlockError extends Error {}
 
+interface AiStream {
+  write: (data: string) => Promise<void>;
+  close: () => Promise<void>;
+  read: () => Promise<string|null>;
+  fail: (e: Error) => void;
+}
+
 export class AidaClient {
+  // Delegate client
+  #gcaClient = new GcaClient.GcaClient();
+
   static buildConsoleInsightsRequest(input: string): DoConversationRequest {
     const disallowLogging = Root.Runtime.hostConfig.aidaAvailability?.disallowLogging ?? true;
     const chromeVersion = Root.Runtime.getChromeVersion();
@@ -145,81 +160,71 @@ export class AidaClient {
       };
     })();
     const streamId = bindOutputStream(stream);
-    DispatchHttpRequestClient
-        .makeHttpRequest(
-            {
-              service: SERVICE_NAME,
-              path: '/v1/aida:doConversation',
-              method: 'POST',
-              body: JSON.stringify(request),
-              streamId,
-            },
-            options)
-        .then(
-            () => {
-              void stream.close();
-            },
-            err => {
-              if (err instanceof DispatchHttpRequestClient.DispatchHttpRequestError && err.response) {
-                const result = err.response;
-                if (result.statusCode === 403) {
-                  stream.fail(new Error('Server responded: permission denied'));
-                  return;
-                }
-                if ('error' in result && result.error) {
-                  stream.fail(new Error(`Cannot send request: ${result.error} ${result.detail || ''}`));
-                  return;
-                }
-                if ('netErrorName' in result && result.netErrorName === 'net::ERR_TIMED_OUT') {
-                  stream.fail(new Error('doAidaConversation timed out'));
-                  return;
-                }
-                if (result.statusCode !== 200) {
-                  stream.fail(new Error(`Request failed: ${JSON.stringify(result)}`));
-                  return;
-                }
-              }
-              stream.fail(err);
-            });
+
+    let response;
+    if (this.#gcaClient.enabled()) {
+      // Inline and remove the else clause after migration
+      response = this.#gcaClient.conversationRequest(request, streamId, options);
+    } else {
+      response = DispatchHttpRequestClient.makeHttpRequest(
+          {
+            service: SERVICE_NAME,
+            path: '/v1/aida:doConversation',
+            method: 'POST',
+            body: JSON.stringify(request),
+            streamId,
+          },
+          options);
+    }
+    response.then(
+        () => {
+          void stream.close();
+        },
+        err => {
+          debugLog('doConversation failed with error:', JSON.stringify(err));
+          if (err instanceof DispatchHttpRequestClient.DispatchHttpRequestError && err.response) {
+            const result = err.response;
+            if (result.statusCode === 403) {
+              stream.fail(new Error('Server responded: permission denied'));
+              return;
+            }
+            if ('error' in result && result.error) {
+              stream.fail(new Error(`Cannot send request: ${result.error} ${result.detail || ''}`));
+              return;
+            }
+            if ('netErrorName' in result && result.netErrorName === 'net::ERR_TIMED_OUT') {
+              stream.fail(new Error('doAidaConversation timed out'));
+              return;
+            }
+            if (result.statusCode !== 200) {
+              stream.fail(new Error(`Request failed: ${JSON.stringify(result)}`));
+              return;
+            }
+          }
+          stream.fail(err);
+        });
+    await (yield* this.#handleResponseStream(stream));
+  }
+
+  async * #handleResponseStream(stream: AiStream): AsyncGenerator<DoConversationResponse, void, void> {
     let chunk;
     const text = [];
     let inCodeChunk = false;
     const functionCalls: AidaFunctionCallResponse[] = [];
     let metadata: ResponseMetadata = {rpcGlobalId: 0};
     while ((chunk = await stream.read())) {
+      debugLog('doConversation stream chunk:', chunk);
       let textUpdated = false;
-      // The AIDA response is a JSON array of objects, split at the object
-      // boundary. Therefore each chunk may start with `[` or `,` and possibly
-      // followed by `]`. Each chunk may include one or more objects, so we
-      // make sure that each chunk becomes a well-formed JSON array when we
-      // parse it by adding `[` and `]` and removing `,` where appropriate.
-      if (!chunk.length) {
-        continue;
-      }
-      if (chunk.startsWith(',')) {
-        chunk = chunk.slice(1);
-      }
-      if (!chunk.startsWith('[')) {
-        chunk = '[' + chunk;
-      }
-      if (!chunk.endsWith(']')) {
-        chunk = chunk + ']';
-      }
-      let results;
-      try {
-        results = JSON.parse(chunk);
-      } catch (error) {
-        throw new Error('Cannot parse chunk: ' + chunk, {cause: error});
-      }
+      const results = this.#parseAndTranslate(chunk);
 
       for (const result of results) {
-        if ('metadata' in result) {
+        if (result.metadata) {
           metadata = result.metadata;
           if (metadata?.attributionMetadata?.attributionAction === RecitationAction.BLOCK) {
             throw new AidaBlockError();
           }
         }
-        if ('textChunk' in result) {
+        if (result.textChunk) {
           if (inCodeChunk) {
             text.push(CODE_CHUNK_SEPARATOR());
             inCodeChunk = false;
@@ -227,7 +232,7 @@ export class AidaClient {
 
           text.push(result.textChunk.text);
           textUpdated = true;
-        } else if ('codeChunk' in result) {
+        } else if (result.codeChunk) {
           if (!inCodeChunk) {
             const language = AidaLanguageToMarkdown[result.codeChunk.inferenceLanguage as AidaInferenceLanguage] ?? '';
             text.push(CODE_CHUNK_SEPARATOR(language));
@@ -236,7 +241,7 @@ export class AidaClient {
 
           text.push(result.codeChunk.code);
           textUpdated = true;
-        } else if ('functionCallChunk' in result) {
+        } else if (result.functionCallChunk) {
           functionCalls.push({
             name: result.functionCallChunk.functionCall.name,
             args: result.functionCallChunk.functionCall.args,
@@ -264,6 +269,40 @@ export class AidaClient {
     };
   }
 
+  #parseAndTranslate(chunk: string): AidaChunkResponse[] {
+    const results: AidaChunkResponse[] = this.#parseStreamChunk(chunk);
+    if (this.#gcaClient.enabled()) {
+      return (results as GenerateContentResponse[]).flatMap(gcaChunkResponseToAidaChunkResponse);
+    }
+    return results as AidaChunkResponse[];
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  #parseStreamChunk(chunk: string): any {
+    // The streamed response is a JSON array of objects, split at the object
+    // boundary. Therefore each chunk may start with `[` or `,` and possibly
+    // followed by `]`. Each chunk may include one or more objects, so we
+    // make sure that each chunk becomes a well-formed JSON array when we
+    // parse it by adding `[` and `]` and removing `,` where appropriate.
+    if (!chunk.length) {
+      return [];
+    }
+    if (chunk.startsWith(',')) {
+      chunk = chunk.slice(1);
+    }
+    if (!chunk.startsWith('[')) {
+      chunk = '[' + chunk;
+    }
+    if (!chunk.endsWith(']')) {
+      chunk = chunk + ']';
+    }
+    try {
+      return JSON.parse(chunk);
+    } catch (error) {
+      throw new Error('Cannot parse chunk: ' + chunk, {cause: error});
+    }
+  }
+
   registerClientEvent(clientEvent: AidaRegisterClientEvent): Promise<AidaClientResult> {
     // Disable logging for now.
     // For context, see b/454563259#comment35.
@@ -272,7 +311,11 @@ export class AidaClient {
       clientEvent.disable_user_content_logging = true;
     }
 
+    if (this.#gcaClient.enabled()) {
+      return this.#gcaClient.registerClientEvent(clientEvent);
+    }
     const {promise, resolve} = Promise.withResolvers<AidaClientResult>();
+
     InspectorFrontendHostInstance.registerAidaClientEvent(
         JSON.stringify({
           client: CLIENT_NAME,
@@ -297,6 +340,9 @@ export class AidaClient {
       request.metadata.disable_user_content_logging = true;
     }
 
+    if (this.#gcaClient.enabled()) {
+      return await this.#gcaClient.completeCode(request);
+    }
     const {promise, resolve} = Promise.withResolvers<AidaCodeCompleteResult>();
     InspectorFrontendHostInstance.aidaCodeComplete(JSON.stringify(request), resolve);
     const completeCodeResult = await promise;
@@ -348,6 +394,11 @@ export class AidaClient {
     if (Root.Runtime.hostConfig.devToolsGeminiRebranding?.enabled) {
       request.metadata.disable_user_content_logging = true;
     }
+
+    if (this.#gcaClient.enabled()) {
+      // Inline and remove the else clause after migration
+      return await this.#gcaClient.generateCode(request, options);
+    }
     const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateCodeResponse>(
         {
           service: SERVICE_NAME,

package/front_end/core/host/AidaGcaTranslation.ts

@@ -254,6 +254,12 @@ function buildLabels(request: AidaRequest, gcaRequest: GCA.GenerateContentReques
   if (options?.expect_code_output !== undefined) {
     labels['expect_code_output'] = String(options.expect_code_output);
   }
+  if (request.metadata.disable_user_content_logging !== undefined) {
+    labels['disable_user_content_logging'] = String(request.metadata.disable_user_content_logging);
+  }
+  if (request.metadata.client_version) {
+    labels['client_version'] = request.metadata.client_version;
+  }
 
   if (Object.keys(labels).length > 0) {
     gcaRequest.labels = labels;

package/front_end/core/host/GcaClient.ts

@@ -0,0 +1,112 @@
+// Copyright 2026 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 Root from '../root/root.js';
+
+import {
+  type AidaRegisterClientEvent,
+  type CompletionRequest,
+  type CompletionResponse,
+  debugLog,
+  type DoConversationRequest,
+  type GenerateCodeRequest,
+  type GenerateCodeResponse
+} from './AidaClientTypes.js';
+import {
+  aidaCompletionRequestToGcaRequest,
+  aidaDoConversationRequestToGcaRequest,
+  aidaEventToGcaTelemetryRequest,
+  aidaGenerateCodeRequestToGcaRequest,
+  gcaResponseToAidaCompletionResponse,
+  gcaResponseToAidaGenerateCodeResponse
+} from './AidaGcaTranslation.js';
+import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
+import type {GenerateContentRequest, GenerateContentResponse} from './GcaTypes.js';
+import type {AidaClientResult} from './InspectorFrontendHostAPI.js';
+
+const SERVICE_NAME = 'gcaService';
+
+const ENDPOINTS = {
+  CONTENT: '/v1beta:generateContent',
+  SEND_TELEMETRY: '/v1beta:sendTelemetry',
+  STREAM_CONTENT: '/v1beta:streamGenerateContent',
+};
+
+export class GcaClient {
+  enabled(): boolean|undefined {
+    return Root.Runtime.hostConfig.devToolsUseGcaApi?.enabled;
+  }
+
+  async conversationRequest(request: DoConversationRequest, streamId: number, options?: {signal?: AbortSignal}):
+      Promise<void> {
+    try {
+      const gcaRequest = aidaDoConversationRequestToGcaRequest(request);
+      const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateContentResponse>(
+          {
+            service: SERVICE_NAME,
+            path: ENDPOINTS.STREAM_CONTENT,
+            method: 'POST',
+            body: JSON.stringify(gcaRequest),
+            streamId,
+          },
+          options);
+      debugLog('GCA conversation request succeeded:', JSON.stringify(request), JSON.stringify(response));
+    } catch (err) {
+      debugLog('GCA request failed:', JSON.stringify(request), err);
+      throw err;
+    }
+  }
+
+  registerClientEvent(clientEvent: AidaRegisterClientEvent): Promise<AidaClientResult> {
+    const gcaEvent = aidaEventToGcaTelemetryRequest(clientEvent);
+    const response = DispatchHttpRequestClient.makeHttpRequest({
+      service: SERVICE_NAME,
+      path: ENDPOINTS.SEND_TELEMETRY,
+      method: 'POST',
+      body: JSON.stringify(gcaEvent),
+    });
+    return response.then(
+        result => {
+          debugLog('GCA register event succeeded:', JSON.stringify(gcaEvent), JSON.stringify(result));
+          return {} as AidaClientResult;
+        },
+        err => {
+          debugLog('GCA register event failed:', JSON.stringify(gcaEvent), err);
+          return {error: JSON.stringify(err)} as AidaClientResult;
+        });
+  }
+
+  async completeCode(request: CompletionRequest): Promise<CompletionResponse|null> {
+    const gcaRequest = aidaCompletionRequestToGcaRequest(request);
+    const result = await this.#requestContent(gcaRequest);
+    const aidaResult = result ? gcaResponseToAidaCompletionResponse(result) : null;
+    return aidaResult;
+  }
+
+  async generateCode(request: GenerateCodeRequest, options?: {signal?: AbortSignal}):
+      Promise<GenerateCodeResponse|null> {
+    const gcaRequest = aidaGenerateCodeRequestToGcaRequest(request);
+    const result = await this.#requestContent(gcaRequest, options);
+    return result ? gcaResponseToAidaGenerateCodeResponse(result) : null;
+  }
+
+  async #requestContent(request: GenerateContentRequest, options?: {signal?: AbortSignal}):
+      Promise<GenerateContentResponse|null> {
+    try {
+      const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateContentResponse>(
+          {
+            service: SERVICE_NAME,
+            path: ENDPOINTS.CONTENT,
+            method: 'POST',
+            body: JSON.stringify(request),
+          },
+          options);
+      debugLog('GCA request succeeded:', JSON.stringify(request), JSON.stringify(response));
+      return response;
+    } catch (err) {
+      debugLog('GCA request failed:', JSON.stringify(request), err);
+      return null;
+    }
+  }
+}

package/front_end/core/host/UserMetrics.ts

@@ -821,7 +821,6 @@ export enum DevtoolsExperiments {
   apca = 39,
   'font-editor' = 41,
   'full-accessibility-tree' = 42,
-  'experimental-cookie-features' = 45,
   'instrumentation-breakpoints' = 61,
   'use-source-map-scopes' = 76,
   'timeline-debug-mode' = 93,

package/front_end/core/host/host.ts

@@ -5,6 +5,7 @@
 import * as AidaClient from './AidaClient.js';
 import * as AidaGcaTranslation from './AidaGcaTranslation.js';
 import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
+import * as GcaClient from './GcaClient.js';
 import * as GcaTypes from './GcaTypes.js';
 import * as GdpClient from './GdpClient.js';
 import * as InspectorFrontendHost from './InspectorFrontendHost.js';
@@ -17,6 +18,7 @@ export {
   AidaClient,
   AidaGcaTranslation,
   DispatchHttpRequestClient,
+  GcaClient,
   GcaTypes,
   GdpClient,
   InspectorFrontendHost,

package/front_end/core/root/ExperimentNames.ts

@@ -14,7 +14,6 @@ export enum ExperimentName {
   APCA = 'apca',
   FONT_EDITOR = 'font-editor',
   FULL_ACCESSIBILITY_TREE = 'full-accessibility-tree',
-  EXPERIMENTAL_COOKIE_FEATURES = 'experimental-cookie-features',
   INSTRUMENTATION_BREAKPOINTS = 'instrumentation-breakpoints',
   USE_SOURCE_MAP_SCOPES = 'use-source-map-scopes',
   TIMELINE_DEBUG_MODE = 'timeline-debug-mode',

package/front_end/core/root/Runtime.ts

@@ -602,6 +602,10 @@ interface ConsoleInsightsTeasers {
   allowWithoutGpu: boolean;
 }
 
+interface UseGcaApi {
+  enabled: boolean;
+}
+
 interface DevToolsProtocolMonitor {
   enabled: boolean;
 }
@@ -662,6 +666,7 @@ export type HostConfig = Platform.TypeScriptUtilities.RecursivePartial<{
   devToolsGeminiRebranding: HostConfigGeminiRebranding,
   devToolsProtocolMonitor: DevToolsProtocolMonitor,
   devToolsWebMCPSupport: DevToolsWebMCPSupport,
+  devToolsUseGcaApi: UseGcaApi,
 }>;
 
 /**

package/front_end/core/sdk/AutofillModel.ts

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as Common from '../../core/common/common.js';
+import type * as Common from '../../core/common/common.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import type * as Protocol from '../../generated/protocol.js';
 import * as Host from '../host/host.js';
@@ -19,8 +19,9 @@ export class AutofillModel extends SDKModel<EventTypes> implements ProtocolProxy
     super(target);
 
     this.agent = target.autofillAgent();
+    const settings = this.target().targetManager().settings;
     this.#showTestAddressesInAutofillMenu =
-        Common.Settings.Settings.instance().createSetting('show-test-addresses-in-autofill-menu-on-event', false);
+        settings.createSetting('show-test-addresses-in-autofill-menu-on-event', false);
     this.#showTestAddressesInAutofillMenu.addChangeListener(this.#setTestAddresses, this);
     target.registerAutofillDispatcher(this);
     this.enable();

package/front_end/core/sdk/CSSModel.ts

@@ -79,10 +79,9 @@ export class CSSModel extends SDKModel<EventTypes> {
       void this.enable();
     }
 
-    this.#sourceMapManager.setEnabled(
-        Common.Settings.Settings.instance().moduleSetting<boolean>('css-source-maps-enabled').get());
-    Common.Settings.Settings.instance()
-        .moduleSetting<boolean>('css-source-maps-enabled')
+    const settings = this.target().targetManager().settings;
+    this.#sourceMapManager.setEnabled(settings.moduleSetting<boolean>('css-source-maps-enabled').get());
+    settings.moduleSetting<boolean>('css-source-maps-enabled')
         .addChangeListener(event => this.#sourceMapManager.setEnabled(event.data));
   }
 

package/front_end/core/sdk/CSSProperty.ts

@@ -225,7 +225,7 @@ export class CSSProperty extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     const range = this.range.relativeTo(this.ownerStyle.range.startLine, this.ownerStyle.range.startColumn);
     const indentation = this.ownerStyle.cssText ?
         this.detectIndentation(this.ownerStyle.cssText) :
-        Common.Settings.Settings.instance().moduleSetting('text-editor-indent').get();
+        this.ownerStyle.cssModel().target().targetManager().settings.moduleSetting('text-editor-indent').get();
     const endIndentation = this.ownerStyle.cssText ? indentation.substring(0, this.ownerStyle.range.endColumn) : '';
     const text = new TextUtils.Text.Text(this.ownerStyle.cssText || '');
     const newStyleText = text.replaceRange(range, Platform.StringUtilities.sprintf(';%s;', propertyText));

package/front_end/core/sdk/ConsoleModel.ts

@@ -153,7 +153,7 @@ export class ConsoleModel extends SDKModel<EventTypes> {
           replMode: true,
           allowUnsafeEvalBlockedByCSP: false,
         },
-        Common.Settings.Settings.instance().moduleSetting('console-user-activation-eval').get(),
+        this.target().targetManager().settings.moduleSetting('console-user-activation-eval').get(),
         /* awaitPromise */ false);
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.ConsoleEvaluated);
     if ('error' in result) {
@@ -284,7 +284,8 @@ export class ConsoleModel extends SDKModel<EventTypes> {
   }
 
   private clearIfNecessary(): void {
-    if (!Common.Settings.Settings.instance().moduleSetting('preserve-console-log').get()) {
+    const settings = this.target().targetManager().settings;
+    if (!settings.moduleSetting('preserve-console-log').get()) {
       this.clear();
     }
     ++this.#pageLoadSequenceNumber;
@@ -292,7 +293,8 @@ export class ConsoleModel extends SDKModel<EventTypes> {
 
   private primaryPageChanged(
       event: Common.EventTarget.EventTargetEvent<{frame: ResourceTreeFrame, type: PrimaryPageChangeType}>): void {
-    if (Common.Settings.Settings.instance().moduleSetting('preserve-console-log').get()) {
+    const settings = this.target().targetManager().settings;
+    if (settings.moduleSetting('preserve-console-log').get()) {
       const {frame} = event.data;
       if (frame.backForwardCacheDetails.restoredFromCache) {
         Common.Console.Console.instance().log(i18nString(UIStrings.bfcacheNavigation, {PH1: frame.url}));
@@ -353,25 +355,25 @@ export class ConsoleModel extends SDKModel<EventTypes> {
   }
 
   // messages[] are not ordered by timestamp.
-  static allMessagesUnordered(): ConsoleMessage[] {
+  static allMessagesUnordered(targetManager: TargetManager = TargetManager.instance()): ConsoleMessage[] {
     const messages = [];
-    for (const target of TargetManager.instance().targets()) {
+    for (const target of targetManager.targets()) {
       const targetMessages = target.model(ConsoleModel)?.messages() || [];
       messages.push(...targetMessages);
     }
     return messages;
   }
 
-  static requestClearMessages(): void {
-    for (const logModel of TargetManager.instance().models(LogModel)) {
+  static requestClearMessages(targetManager: TargetManager = TargetManager.instance()): void {
+    for (const logModel of targetManager.models(LogModel)) {
       logModel.requestClear();
     }
-    for (const runtimeModel of TargetManager.instance().models(RuntimeModel)) {
+    for (const runtimeModel of targetManager.models(RuntimeModel)) {
       runtimeModel.discardConsoleEntries();
       // Runtime.discardConsoleEntries implies Runtime.releaseObjectGroup('console').
       runtimeModel.releaseObjectGroup('live-expression');
     }
-    for (const target of TargetManager.instance().targets()) {
+    for (const target of targetManager.targets()) {
       target.model(ConsoleModel)?.clear();
     }
   }
@@ -390,9 +392,9 @@ export class ConsoleModel extends SDKModel<EventTypes> {
     return this.#errors;
   }
 
-  static allErrors(): number {
+  static allErrors(targetManager: TargetManager = TargetManager.instance()): number {
     let errors = 0;
-    for (const target of TargetManager.instance().targets()) {
+    for (const target of targetManager.targets()) {
       errors += target.model(ConsoleModel)?.errors() || 0;
     }
     return errors;
@@ -402,9 +404,9 @@ export class ConsoleModel extends SDKModel<EventTypes> {
     return this.#warnings;
   }
 
-  static allWarnings(): number {
+  static allWarnings(targetManager: TargetManager = TargetManager.instance()): number {
     let warnings = 0;
-    for (const target of TargetManager.instance().targets()) {
+    for (const target of targetManager.targets()) {
       warnings += target.model(ConsoleModel)?.warnings() || 0;
     }
     return warnings;

package/front_end/core/sdk/CookieModel.ts

@@ -99,8 +99,9 @@ export class CookieModel extends SDKModel<EventTypes> {
     if (cookie.expires()) {
       expires = Math.floor(Date.parse(`${cookie.expires()}`) / 1000);
     }
-    const enabled =
-        Root.Runtime.experiments.isEnabled(Root.ExperimentNames.ExperimentName.EXPERIMENTAL_COOKIE_FEATURES);
+    const schemeBindingEnabled =
+        Boolean(Root.Runtime.hostConfig.devToolsEnableOriginBoundCookies?.schemeBindingEnabled);
+    const portBindingEnabled = Boolean(Root.Runtime.hostConfig.devToolsEnableOriginBoundCookies?.portBindingEnabled);
     const preserveUnset = (scheme: Protocol.Network.CookieSourceScheme): Protocol.Network.CookieSourceScheme.Unset|
                           undefined => scheme === Protocol.Network.CookieSourceScheme.Unset ? scheme : undefined;
     const protocolCookie = {
@@ -115,8 +116,8 @@ export class CookieModel extends SDKModel<EventTypes> {
       expires,
       priority: cookie.priority(),
       partitionKey: cookie.partitionKey(),
-      sourceScheme: enabled ? cookie.sourceScheme() : preserveUnset(cookie.sourceScheme()),
-      sourcePort: enabled ? cookie.sourcePort() : undefined,
+      sourceScheme: schemeBindingEnabled ? cookie.sourceScheme() : preserveUnset(cookie.sourceScheme()),
+      sourcePort: portBindingEnabled ? cookie.sourcePort() : undefined,
     };
     const response = await this.target().networkAgent().invoke_setCookie(protocolCookie);
     const error = response.getError();