chrome-devtools-frontend 1.0.1591204 → 1.0.1592362

package/docs/ui_engineering.md

@@ -611,7 +611,7 @@ export const DEFAULT_VIEW = (input, _output, target) => {
       <a href="https://www.google.com" data-some-key="some-value" role="some-role">some-text</a>
       <img src="https://www.google.com/some-image.png" alt="some-alt" draggable="true" height="100"
           hidden="hidden" href="https://www.google.com" id="some-id" name="some-name" rel="some-rel"
-          scope="some-scope"></img>
+          scope="some-scope">
       <input type="text" placeholder="some-placeholder" value="some-value"
           ?disabled=${!this.enabled} checked>
     </div>`,

package/front_end/core/host/AidaClient.ts

@@ -528,8 +528,8 @@ export class AidaClient {
   async *
       doConversation(request: DoConversationRequest, options?: {signal?: AbortSignal}):
           AsyncGenerator<DoConversationResponse, void, void> {
-    if (!InspectorFrontendHostInstance.doAidaConversation) {
-      throw new Error('doAidaConversation is not available');
+    if (!InspectorFrontendHostInstance.dispatchHttpRequest) {
+      throw new Error('dispatchHttpRequest is not available');
     }
 
     // Disable logging for now.
@@ -559,19 +559,42 @@ export class AidaClient {
       };
     })();
     const streamId = bindOutputStream(stream);
-    InspectorFrontendHostInstance.doAidaConversation(JSON.stringify(request), streamId, result => {
-      if (result.statusCode === 403) {
-        stream.fail(new Error('Server responded: permission denied'));
-      } else if (result.error) {
-        stream.fail(new Error(`Cannot send request: ${result.error} ${result.detail || ''}`));
-      } else if (result.netErrorName === 'net::ERR_TIMED_OUT') {
-        stream.fail(new Error('doAidaConversation timed out'));
-      } else if (result.statusCode !== 200) {
-        stream.fail(new Error(`Request failed: ${JSON.stringify(result)}`));
-      } else {
-        void stream.close();
-      }
-    });
+    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 chunk;
     const text = [];
     let inCodeChunk = false;

package/front_end/core/host/DispatchHttpRequestClient.ts

@@ -12,7 +12,7 @@ export enum ErrorType {
 }
 
 export class DispatchHttpRequestError extends Error {
-  constructor(readonly type: ErrorType, options?: ErrorOptions) {
+  constructor(readonly type: ErrorType, readonly response?: DispatchHttpRequestResult, options?: ErrorOptions) {
     super(undefined, options);
   }
 }
@@ -38,18 +38,21 @@ export async function makeHttpRequest<R>(
 
   debugLog({request, response});
   if (response.statusCode === 404) {
-    throw new DispatchHttpRequestError(ErrorType.NOT_FOUND);
+    throw new DispatchHttpRequestError(ErrorType.NOT_FOUND, response);
   }
 
   if ('response' in response && response.statusCode === 200) {
+    if (request.streamId && !response.response) {
+      return null as R;
+    }
     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, response, {cause: err});
     }
   }
 
-  throw new DispatchHttpRequestError(ErrorType.HTTP_RESPONSE_UNAVAILABLE);
+  throw new DispatchHttpRequestError(ErrorType.HTTP_RESPONSE_UNAVAILABLE, response);
 }
 
 function isDebugMode(): boolean {

package/front_end/core/host/InspectorFrontendHostAPI.ts

@@ -263,12 +263,14 @@ export type DispatchHttpRequestRequest = {
   path: string,
   method: 'GET',
   queryParams?: Record<string, string|string[]>,
+  streamId?: number,
   body?: never,
 }|{
   service: string,
   path: string,
   method: 'POST',
   queryParams?: Record<string, string|string[]>,
+  streamId?: number,
   // A JSON string containing the request body.
   body?: string,
 };

package/front_end/core/host/UserMetrics.ts

@@ -826,10 +826,11 @@ export enum DevtoolsExperiments {
   'timeline-show-postmessage-events' = 86,
   'timeline-debug-mode' = 93,
   'durable-messages' = 110,
+  'jpeg-xl' = 111,
   /* eslint-enable @typescript-eslint/naming-convention */
 
   // Increment this when new experiments are added.
-  MAX_VALUE = 111,
+  MAX_VALUE = 112,
 }
 
 /** Update DevToolsIssuesPanelIssueExpanded from tools/metrics/histograms/enums.xml if new enum is added. **/

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -559,6 +559,10 @@ export class TargetBase {
     this.registerDispatcher('DOMStorage', dispatcher);
   }
 
+  registerEmulationDispatcher(dispatcher: ProtocolProxyApi.EmulationDispatcher): void {
+    this.registerDispatcher('Emulation', dispatcher);
+  }
+
   registerFetchDispatcher(dispatcher: ProtocolProxyApi.FetchDispatcher): void {
     this.registerDispatcher('Fetch', dispatcher);
   }

package/front_end/core/root/ExperimentNames.ts

@@ -24,6 +24,7 @@ export enum ExperimentName {
   TIMELINE_SHOW_POST_MESSAGE_EVENTS = 'timeline-show-postmessage-events',
   TIMELINE_DEBUG_MODE = 'timeline-debug-mode',
   DURABLE_MESSAGES = 'durable-messages',
+  JPEG_XL = 'jpeg-xl',
   // Adding or removing an entry from this enum?
   // You will need to update:
   // 1. DevToolsExperiments enum in host/UserMetrics.ts

package/front_end/core/sdk/CSSMetadata.ts

@@ -1344,6 +1344,24 @@ const extraPropertyValues = new Map<string, Set<string>>([
   ['-webkit-transform-origin-x', new Set(['left', 'right', 'center'])],
   ['-webkit-transform-origin-y', new Set(['top', 'bottom', 'center'])],
   ['width', new Set(['-webkit-fill-available', 'stretch'])],
+  [
+    'animation-trigger',
+    new Set([
+      'play',
+      'pause',
+      'play-once',
+      'play-alternate',
+      'play-forwards',
+      'play-backwards',
+      'play-pause',
+      'replay',
+    ]),
+  ],
+  ['timeline-trigger-activation-range-start', new Set(['normal'])],
+  ['timeline-trigger-activation-range-end', new Set(['normal'])],
+  ['timeline-trigger-active-range-start', new Set(['normal'])],
+  ['timeline-trigger-active-range-end', new Set(['normal'])],
+
   ['contain-intrinsic-width', new Set(['auto none', 'auto 100px'])],
   ['contain-intrinsic-height', new Set(['auto none', 'auto 100px'])],
   ['contain-intrinsic-size', new Set(['auto none', 'auto 100px'])],

package/front_end/core/sdk/EmulationModel.ts

@@ -18,7 +18,7 @@ export const enum DataSaverOverride {
   DISABLED = 'disabled',
 }
 
-export class EmulationModel extends SDKModel<void> {
+export class EmulationModel extends SDKModel<EmulationModelEventTypes> implements ProtocolProxyApi.EmulationDispatcher {
   readonly #emulationAgent: ProtocolProxyApi.EmulationApi;
   readonly #deviceOrientationAgent: ProtocolProxyApi.DeviceOrientationApi;
   #cssModel: CSSModel|null;
@@ -33,11 +33,15 @@ export class EmulationModel extends SDKModel<void> {
     enabled: boolean,
     configuration: Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration,
   };
+  #screenOrientationLocked: boolean;
+  #lockedOrientation: Protocol.Emulation.ScreenOrientation|null;
 
   constructor(target: Target) {
     super(target);
     this.#emulationAgent = target.emulationAgent();
     this.#deviceOrientationAgent = target.deviceOrientationAgent();
+    this.#screenOrientationLocked = false;
+    this.#lockedOrientation = null;
     this.#cssModel = target.model(CSSModel);
     this.#overlayModel = target.model(OverlayModel);
     if (this.#overlayModel) {
@@ -225,6 +229,7 @@ export class EmulationModel extends SDKModel<void> {
       enabled: false,
       configuration: Protocol.Emulation.SetEmitTouchEventsForMouseRequestConfiguration.Mobile,
     };
+    target.registerEmulationDispatcher(this);
   }
 
   setTouchEmulationAllowed(touchEmulationAllowed: boolean): void {
@@ -478,6 +483,41 @@ export class EmulationModel extends SDKModel<void> {
     ];
     return await this.emulateCSSMedia(type, features);
   }
+
+  // ProtocolProxyApi.EmulationDispatcher implementation
+
+  virtualTimeBudgetExpired(): void {
+    // No-op for now; not used by the frontend.
+  }
+
+  screenOrientationLockChanged(event: Protocol.Emulation.ScreenOrientationLockChangedEvent): void {
+    this.#screenOrientationLocked = event.locked;
+    this.#lockedOrientation = event.orientation ?? null;
+    this.dispatchEventToListeners(
+        EmulationModelEvents.SCREEN_ORIENTATION_LOCK_CHANGED,
+        {locked: event.locked, orientation: event.orientation ?? null});
+  }
+
+  isScreenOrientationLocked(): boolean {
+    return this.#screenOrientationLocked;
+  }
+
+  lockedOrientation(): Protocol.Emulation.ScreenOrientation|null {
+    return this.#lockedOrientation;
+  }
+}
+
+export const enum EmulationModelEvents {
+  SCREEN_ORIENTATION_LOCK_CHANGED = 'ScreenOrientationLockChanged',
+}
+
+export interface ScreenOrientationLockChangedEvent {
+  locked: boolean;
+  orientation: Protocol.Emulation.ScreenOrientation|null;
+}
+
+export interface EmulationModelEventTypes {
+  [EmulationModelEvents.SCREEN_ORIENTATION_LOCK_CHANGED]: ScreenOrientationLockChangedEvent;
 }
 
 export class Location {

package/front_end/core/sdk/RuntimeModel.ts

@@ -262,7 +262,8 @@ export class RuntimeModel extends SDKModel<EventTypes> {
     }
 
     if (object.isNode()) {
-      void Common.Revealer.reveal(object).then(object.release.bind(object));
+      const omitFocus = hints !== null && typeof hints === 'object' && 'omitFocus' in hints && Boolean(hints.omitFocus);
+      void Common.Revealer.reveal(object, omitFocus).then(object.release.bind(object));
       return;
     }
 

package/front_end/entrypoints/main/MainImpl.ts

@@ -431,6 +431,14 @@ export class MainImpl {
       requiresChromeRestart: false,
     });
 
+    Root.Runtime.experiments.registerHostExperiment({
+      name: Root.ExperimentNames.ExperimentName.JPEG_XL,
+      title: 'JPEG XL support',
+      aboutFlag: 'enable-jxl-image-format',
+      isEnabled: Root.Runtime.hostConfig.devToolsJpegXlImageFormat?.enabled ?? false,
+      requiresChromeRestart: true,
+    });
+
     Root.Runtime.experiments.enableExperimentsByDefault([
       Root.ExperimentNames.ExperimentName.FULL_ACCESSIBILITY_TREE,
       Root.ExperimentNames.ExperimentName.USE_SOURCE_MAP_SCOPES,

package/front_end/generated/InspectorBackendCommands.ts

@@ -508,6 +508,7 @@ inspectorBackend.registerEnum("Emulation.PressureSource", {Cpu: "cpu"});
 inspectorBackend.registerEnum("Emulation.PressureState", {Nominal: "nominal", Fair: "fair", Serious: "serious", Critical: "critical"});
 inspectorBackend.registerEnum("Emulation.DisabledImageType", {Avif: "avif", Jxl: "jxl", Webp: "webp"});
 inspectorBackend.registerEvent("Emulation.virtualTimeBudgetExpired", []);
+inspectorBackend.registerEvent("Emulation.screenOrientationLockChanged", ["locked", "orientation"]);
 inspectorBackend.registerCommand("Emulation.canEmulate", [], ["result"], "Tells whether emulation is supported.");
 inspectorBackend.registerCommand("Emulation.clearDeviceMetricsOverride", [], [], "Clears the overridden device metrics.");
 inspectorBackend.registerCommand("Emulation.clearGeolocationOverride", [], [], "Clears the overridden Geolocation Position and Error.");

package/front_end/generated/protocol-mapping.d.ts

@@ -202,6 +202,12 @@ export namespace ProtocolMapping {
      * Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.
      */
     'Emulation.virtualTimeBudgetExpired': [];
+    /**
+     * Fired when a page calls screen.orientation.lock() or screen.orientation.unlock()
+     * while device emulation is enabled. This allows the DevTools frontend to update the
+     * emulated device orientation accordingly.
+     */
+    'Emulation.screenOrientationLockChanged': [Protocol.Emulation.ScreenOrientationLockChangedEvent];
     'FedCm.dialogShown': [Protocol.FedCm.DialogShownEvent];
     /**
      * Triggered when a dialog is closed, either by user action, JS abort,

package/front_end/generated/protocol-proxy-api.d.ts

@@ -1867,6 +1867,13 @@ declare namespace ProtocolProxyApi {
      */
     virtualTimeBudgetExpired(): void;
 
+    /**
+     * Fired when a page calls screen.orientation.lock() or screen.orientation.unlock()
+     * while device emulation is enabled. This allows the DevTools frontend to update the
+     * emulated device orientation accordingly.
+     */
+    screenOrientationLockChanged(params: Protocol.Emulation.ScreenOrientationLockChangedEvent): void;
+
   }
 
   export interface EventBreakpointsApi {

package/front_end/generated/protocol.ts

@@ -7554,6 +7554,22 @@ export namespace Emulation {
   export interface SetPrimaryScreenRequest {
     screenId: ScreenId;
   }
+
+  /**
+   * Fired when a page calls screen.orientation.lock() or screen.orientation.unlock()
+   * while device emulation is enabled. This allows the DevTools frontend to update the
+   * emulated device orientation accordingly.
+   */
+  export interface ScreenOrientationLockChangedEvent {
+    /**
+     * Whether the screen orientation is currently locked.
+     */
+    locked: boolean;
+    /**
+     * The orientation lock type requested by the page. Only set when locked is true.
+     */
+    orientation?: ScreenOrientation;
+  }
 }
 
 /**
@@ -10157,7 +10173,7 @@ export namespace Network {
   }
 
   /**
-   * The render blocking behavior of a resource request.
+   * The render-blocking behavior of a resource request.
    */
   export const enum RenderBlockingBehavior {
     Blocking = 'Blocking',
@@ -12674,7 +12690,7 @@ export namespace Network {
      */
     hasUserGesture?: boolean;
     /**
-     * The render blocking behavior of the request.
+     * The render-blocking behavior of the request.
      */
     renderBlockingBehavior?: RenderBlockingBehavior;
   }

package/front_end/models/ai_assistance/AiConversation.ts

@@ -6,6 +6,7 @@ import * as Host from '../../core/host/host.js';
 import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Trace from '../../models/trace/trace.js';
+import * as Greendev from '../greendev/greendev.js';
 import * as NetworkTimeCalculator from '../network_time_calculator/network_time_calculator.js';
 
 import {
@@ -17,6 +18,7 @@ import {
   ResponseType,
   type UserQuery
 } from './agents/AiAgent.js';
+import {BreakpointDebuggerAgent} from './agents/BreakpointDebuggerAgent.js';
 import {ContextSelectionAgent} from './agents/ContextSelectionAgent.js';
 import {FileAgent, FileContext} from './agents/FileAgent.js';
 import {NetworkAgent, RequestContext} from './agents/NetworkAgent.js';
@@ -326,6 +328,13 @@ export class AiConversation {
         this.#agent = new PerformanceAgent(options);
         break;
       }
+      case ConversationType.BREAKPOINT: {
+        const breakpointAgentEnabled = Greendev.Prototypes.instance().isEnabled('breakpointDebuggerAgent');
+        if (breakpointAgentEnabled) {
+          this.#agent = new BreakpointDebuggerAgent(options);
+        }
+        break;
+      }
       case ConversationType.NONE: {
         this.#agent = new ContextSelectionAgent(options);
         break;

package/front_end/models/ai_assistance/AiHistoryStorage.ts

@@ -13,6 +13,7 @@ export const enum ConversationType {
   FILE = 'drjones-file',
   NETWORK = 'drjones-network-request',
   PERFORMANCE = 'drjones-performance-full',
+  BREAKPOINT = 'breakpoint',
 }
 
 export interface SerializedConversation {

package/front_end/models/ai_assistance/agents/AiAgent.ts

@@ -5,6 +5,7 @@
 import * as Host from '../../../core/host/host.js';
 import * as Root from '../../../core/root/root.js';
 import type * as SDK from '../../../core/sdk/sdk.js';
+import * as Greendev from '../../greendev/greendev.js';
 import {debugLog, isStructuredLogEnabled} from '../debug.js';
 
 export const enum ResponseType {
@@ -534,7 +535,11 @@ export abstract class AiAgent<T> {
 
     yield* this.handleContextDetails(options.selected);
 
-    for (let i = 0; i < MAX_STEPS; i++) {
+    const breakpointAgentEnabled = Greendev.Prototypes.instance().isEnabled('breakpointDebuggerAgent');
+    const isBreakpointDebuggerAgent = this.constructor.name === 'BreakpointDebuggerAgent';
+    const finalMaxSteps = (isBreakpointDebuggerAgent && breakpointAgentEnabled) ? 1000 : MAX_STEPS;
+
+    for (let i = 0; i < finalMaxSteps; i++) {
       yield {
         type: ResponseType.QUERYING,
       };