chrome-devtools-frontend 1.0.1512147 → 1.0.1513662

package/front_end/core/host/ResourceLoader.ts

@@ -272,11 +272,11 @@ export const loadAsStream = function(
 
   function dataURLDecodeSuccessful(text: string): void {
     streamWrite(streamId, text);
-    finishedCallback(({statusCode: 200} as LoadNetworkResourceResult));
+    finishedCallback(({statusCode: 200}));
   }
 
   function dataURLDecodeFailed(_xhrStatus: Error): void {
     const messageOverride: string = i18nString(UIStrings.decodingDataUrlFailed);
-    finishedCallback(({statusCode: 404, messageOverride} as LoadNetworkResourceResult));
+    finishedCallback(({statusCode: 404, messageOverride}));
   }
 };

package/front_end/core/host/UserMetrics.ts

@@ -817,14 +817,12 @@ export enum DevtoolsExperiments {
   'instrumentation-breakpoints' = 61,
   'authored-deployed-grouping' = 63,
   'just-my-code' = 65,
-  'highlight-errors-elements-panel' = 73,
   'use-source-map-scopes' = 76,
   'timeline-show-postmessage-events' = 86,
   'timeline-save-as-gz' = 108,
   'timeline-enhanced-traces' = 90,
   'timeline-compiled-sources' = 91,
   'timeline-debug-mode' = 93,
-  'vertical-drawer' = 107,
   /* eslint-enable @typescript-eslint/naming-convention */
 
   // Increment this when new experiments are added.

package/front_end/core/i18n/NumberFormatter.ts

@@ -39,6 +39,13 @@ export function defineFormatter(options: Intl.NumberFormatOptions): NumberFormat
  * We don't like that, so when there is no space literal we inject the provided separator manually.
  */
 function formatAndEnsureSpace(formatter: Intl.NumberFormat, value: number, separator = '\xA0'): string {
+  // TODO(crbug.com/443038315): this method is defined in
+  // models/ai_assistance in the UnitFormatters file. We can't currently
+  // re-use it because various models depend on i18n and that creates a
+  // circular build.
+  // We should move the unit formatters to their own model so it can be
+  // used across the codebase.
+
   const parts = formatter.formatToParts(value);
 
   let hasSpace = false;

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -507,7 +507,7 @@ interface DispatcherMap extends Map<ProtocolDomainName, ProtocolProxyApi.Protoco
 export class TargetBase {
   needsNodeJSPatching: boolean;
   readonly sessionId: string;
-  routerInternal: SessionRouter|null;
+  #router: SessionRouter|null;
   #agents: AgentsMap = new Map();
   #dispatchers: DispatcherMap = new Map();
 
@@ -521,15 +521,15 @@ export class TargetBase {
     }
 
     let router: SessionRouter;
-    if (sessionId && parentTarget?.routerInternal) {
-      router = parentTarget.routerInternal;
+    if (sessionId && parentTarget && parentTarget.#router) {
+      router = parentTarget.#router;
     } else if (connection) {
       router = new SessionRouter(connection);
     } else {
       router = new SessionRouter(connectionFactory());
     }
 
-    this.routerInternal = router;
+    this.#router = router;
 
     router.registerSession(this, this.sessionId);
 
@@ -557,15 +557,15 @@ export class TargetBase {
   }
 
   dispose(_reason: string): void {
-    if (!this.routerInternal) {
+    if (!this.#router) {
       return;
     }
-    this.routerInternal.unregisterSession(this.sessionId);
-    this.routerInternal = null;
+    this.#router.unregisterSession(this.sessionId);
+    this.#router = null;
   }
 
   isDisposed(): boolean {
-    return !this.routerInternal;
+    return !this.#router;
   }
 
   markAsNodeJSForTest(): void {
@@ -573,7 +573,7 @@ export class TargetBase {
   }
 
   router(): SessionRouter|null {
-    return this.routerInternal;
+    return this.#router;
   }
 
   // Agent accessors, keep alphabetically sorted.

package/front_end/core/root/Runtime.ts

@@ -321,14 +321,12 @@ export const enum ExperimentName {
   INSTRUMENTATION_BREAKPOINTS = 'instrumentation-breakpoints',
   AUTHORED_DEPLOYED_GROUPING = 'authored-deployed-grouping',
   JUST_MY_CODE = 'just-my-code',
-  HIGHLIGHT_ERRORS_ELEMENTS_PANEL = 'highlight-errors-elements-panel',
   USE_SOURCE_MAP_SCOPES = 'use-source-map-scopes',
   TIMELINE_SHOW_POST_MESSAGE_EVENTS = 'timeline-show-postmessage-events',
   TIMELINE_DEBUG_MODE = 'timeline-debug-mode',
   TIMELINE_ENHANCED_TRACES = 'timeline-enhanced-traces',
   TIMELINE_COMPILED_SOURCES = 'timeline-compiled-sources',
   TIMELINE_SAVE_AS_GZ = 'timeline-save-as-gz',
-  VERTICAL_DRAWER = 'vertical-drawer',
   // Adding or removing an entry from this enum?
   // You will need to update:
   // 1. REGISTERED_EXPERIMENTS in EnvironmentHelpers.ts (to create this experiment in the test env)
@@ -486,6 +484,10 @@ interface LiveEdit {
   enabled: boolean;
 }
 
+interface DevToolsFlexibleLayout {
+  verticalDrawerEnabled: boolean;
+}
+
 /**
  * The host configuration that we expect from the DevTools back-end.
  *
@@ -529,6 +531,7 @@ export type HostConfig = Platform.TypeScriptUtilities.RecursivePartial<{
   devToolsGlobalAiButton: GlobalAiButton,
   devToolsGdpProfiles: GdpProfiles,
   devToolsLiveEdit: LiveEdit,
+  devToolsFlexibleLayout: DevToolsFlexibleLayout,
 }>;
 
 /**

package/front_end/core/sdk/AccessibilityModel.ts

@@ -22,44 +22,44 @@ export interface CoreOrProtocolAxProperty {
 }
 
 export class AccessibilityNode {
-  readonly #accessibilityModelInternal: AccessibilityModel;
-  readonly #idInternal: Protocol.Accessibility.AXNodeId;
-  readonly #backendDOMNodeIdInternal: Protocol.DOM.BackendNodeId|null;
-  readonly #deferredDOMNodeInternal: DeferredDOMNode|null;
-  readonly #ignoredInternal: boolean;
-  readonly #ignoredReasonsInternal: Protocol.Accessibility.AXProperty[]|undefined;
-  readonly #roleInternal: Protocol.Accessibility.AXValue|null;
-  readonly #nameInternal: Protocol.Accessibility.AXValue|null;
-  readonly #descriptionInternal: Protocol.Accessibility.AXValue|null;
-  readonly #valueInternal: Protocol.Accessibility.AXValue|null;
-  readonly #propertiesInternal: Protocol.Accessibility.AXProperty[]|null;
+  readonly #accessibilityModel: AccessibilityModel;
+  readonly #id: Protocol.Accessibility.AXNodeId;
+  readonly #backendDOMNodeId: Protocol.DOM.BackendNodeId|null;
+  readonly #deferredDOMNode: DeferredDOMNode|null;
+  readonly #ignored: boolean;
+  readonly #ignoredReasons: Protocol.Accessibility.AXProperty[]|undefined;
+  readonly #role: Protocol.Accessibility.AXValue|null;
+  readonly #name: Protocol.Accessibility.AXValue|null;
+  readonly #description: Protocol.Accessibility.AXValue|null;
+  readonly #value: Protocol.Accessibility.AXValue|null;
+  readonly #properties: Protocol.Accessibility.AXProperty[]|null;
   readonly #parentId: Protocol.Accessibility.AXNodeId|null;
   readonly #frameId: Protocol.Page.FrameId|null;
   readonly #childIds: Protocol.Accessibility.AXNodeId[]|null;
 
   constructor(accessibilityModel: AccessibilityModel, payload: Protocol.Accessibility.AXNode) {
-    this.#accessibilityModelInternal = accessibilityModel;
+    this.#accessibilityModel = accessibilityModel;
 
-    this.#idInternal = payload.nodeId;
-    accessibilityModel.setAXNodeForAXId(this.#idInternal, this);
+    this.#id = payload.nodeId;
+    accessibilityModel.setAXNodeForAXId(this.#id, this);
     if (payload.backendDOMNodeId) {
       accessibilityModel.setAXNodeForBackendDOMNodeId(payload.backendDOMNodeId, this);
-      this.#backendDOMNodeIdInternal = payload.backendDOMNodeId;
-      this.#deferredDOMNodeInternal = new DeferredDOMNode(accessibilityModel.target(), payload.backendDOMNodeId);
+      this.#backendDOMNodeId = payload.backendDOMNodeId;
+      this.#deferredDOMNode = new DeferredDOMNode(accessibilityModel.target(), payload.backendDOMNodeId);
     } else {
-      this.#backendDOMNodeIdInternal = null;
-      this.#deferredDOMNodeInternal = null;
+      this.#backendDOMNodeId = null;
+      this.#deferredDOMNode = null;
     }
-    this.#ignoredInternal = payload.ignored;
-    if (this.#ignoredInternal && 'ignoredReasons' in payload) {
-      this.#ignoredReasonsInternal = payload.ignoredReasons;
+    this.#ignored = payload.ignored;
+    if (this.#ignored && 'ignoredReasons' in payload) {
+      this.#ignoredReasons = payload.ignoredReasons;
     }
 
-    this.#roleInternal = payload.role || null;
-    this.#nameInternal = payload.name || null;
-    this.#descriptionInternal = payload.description || null;
-    this.#valueInternal = payload.value || null;
-    this.#propertiesInternal = payload.properties || null;
+    this.#role = payload.role || null;
+    this.#name = payload.name || null;
+    this.#description = payload.description || null;
+    this.#value = payload.value || null;
+    this.#properties = payload.properties || null;
     this.#childIds = [...new Set(payload.childIds)];
     this.#parentId = payload.parentId || null;
     if (payload.frameId && !payload.parentId) {
@@ -71,74 +71,74 @@ export class AccessibilityNode {
   }
 
   id(): Protocol.Accessibility.AXNodeId {
-    return this.#idInternal;
+    return this.#id;
   }
 
   accessibilityModel(): AccessibilityModel {
-    return this.#accessibilityModelInternal;
+    return this.#accessibilityModel;
   }
 
   ignored(): boolean {
-    return this.#ignoredInternal;
+    return this.#ignored;
   }
 
   ignoredReasons(): Protocol.Accessibility.AXProperty[]|null {
-    return this.#ignoredReasonsInternal || null;
+    return this.#ignoredReasons || null;
   }
 
   role(): Protocol.Accessibility.AXValue|null {
-    return this.#roleInternal || null;
+    return this.#role || null;
   }
 
   coreProperties(): CoreOrProtocolAxProperty[] {
     const properties: CoreOrProtocolAxProperty[] = [];
 
-    if (this.#nameInternal) {
-      properties.push({name: CoreAxPropertyName.NAME, value: this.#nameInternal});
+    if (this.#name) {
+      properties.push({name: CoreAxPropertyName.NAME, value: this.#name});
     }
-    if (this.#descriptionInternal) {
-      properties.push({name: CoreAxPropertyName.DESCRIPTION, value: this.#descriptionInternal});
+    if (this.#description) {
+      properties.push({name: CoreAxPropertyName.DESCRIPTION, value: this.#description});
     }
-    if (this.#valueInternal) {
-      properties.push({name: CoreAxPropertyName.VALUE, value: this.#valueInternal});
+    if (this.#value) {
+      properties.push({name: CoreAxPropertyName.VALUE, value: this.#value});
     }
 
     return properties;
   }
 
   name(): Protocol.Accessibility.AXValue|null {
-    return this.#nameInternal || null;
+    return this.#name || null;
   }
 
   description(): Protocol.Accessibility.AXValue|null {
-    return this.#descriptionInternal || null;
+    return this.#description || null;
   }
 
   value(): Protocol.Accessibility.AXValue|null {
-    return this.#valueInternal || null;
+    return this.#value || null;
   }
 
   properties(): Protocol.Accessibility.AXProperty[]|null {
-    return this.#propertiesInternal || null;
+    return this.#properties || null;
   }
 
   parentNode(): AccessibilityNode|null {
     if (this.#parentId) {
-      return this.#accessibilityModelInternal.axNodeForId(this.#parentId);
+      return this.#accessibilityModel.axNodeForId(this.#parentId);
     }
     return null;
   }
 
   isDOMNode(): boolean {
-    return Boolean(this.#backendDOMNodeIdInternal);
+    return Boolean(this.#backendDOMNodeId);
   }
 
   backendDOMNodeId(): Protocol.DOM.BackendNodeId|null {
-    return this.#backendDOMNodeIdInternal;
+    return this.#backendDOMNodeId;
   }
 
   deferredDOMNode(): DeferredDOMNode|null {
-    return this.#deferredDOMNodeInternal;
+    return this.#deferredDOMNode;
   }
 
   highlightDOMNode(): void {
@@ -157,7 +157,7 @@ export class AccessibilityNode {
 
     const children = [];
     for (const childId of this.#childIds) {
-      const child = this.#accessibilityModelInternal.axNodeForId(childId);
+      const child = this.#accessibilityModel.axNodeForId(childId);
       if (child) {
         children.push(child);
       }
@@ -177,14 +177,14 @@ export class AccessibilityNode {
     if (!this.#childIds || !this.#childIds.length) {
       return false;
     }
-    return this.#childIds.every(id => this.#accessibilityModelInternal.axNodeForId(id) === null);
+    return this.#childIds.every(id => this.#accessibilityModel.axNodeForId(id) === null);
   }
 
   hasUnloadedChildren(): boolean {
     if (!this.#childIds || !this.#childIds.length) {
       return false;
     }
-    return this.#childIds.some(id => this.#accessibilityModelInternal.axNodeForId(id) === null);
+    return this.#childIds.some(id => this.#accessibilityModel.axNodeForId(id) === null);
   }
   // Only the root node gets a frameId, so nodes have to walk up the tree to find their frameId.
   getFrameId(): Protocol.Page.FrameId|null {