chrome-devtools-frontend 1.0.1512349 → 1.0.1513662

package/front_end/core/common/SegmentedRange.ts

@@ -24,56 +24,55 @@ export class Segment<T> {
 }
 
 export class SegmentedRange<T> {
-  #segmentsInternal: 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.#segmentsInternal = [];
+    this.#segments = [];
     this.#mergeCallback = mergeCallback;
   }
 
   append(newSegment: Segment<T>): void {
     // 1. Find the proper insertion point for new segment
-    let startIndex =
-        Platform.ArrayUtilities.lowerBound(this.#segmentsInternal, newSegment, (a, b) => a.begin - b.begin);
+    let startIndex = Platform.ArrayUtilities.lowerBound(this.#segments, newSegment, (a, b) => a.begin - b.begin);
     let endIndex = startIndex;
     let merged: (Segment<T>|null)|null = null;
     if (startIndex > 0) {
       // 2. Try mering the preceding segment
-      const precedingSegment = this.#segmentsInternal[startIndex - 1];
+      const precedingSegment = this.#segments[startIndex - 1];
       merged = this.tryMerge(precedingSegment, newSegment);
       if (merged) {
         --startIndex;
         newSegment = merged;
-      } else if (this.#segmentsInternal[startIndex - 1].end >= newSegment.begin) {
+      } else if (this.#segments[startIndex - 1].end >= newSegment.begin) {
         // 2a. If merge failed and segments overlap, adjust preceding segment.
         // If an old segment entirely contains new one, split it in two.
         if (newSegment.end < precedingSegment.end) {
-          this.#segmentsInternal.splice(
+          this.#segments.splice(
               startIndex, 0, new Segment<T>(newSegment.end, precedingSegment.end, precedingSegment.data));
         }
         precedingSegment.end = newSegment.begin;
       }
     }
     // 3. Consume all segments that are entirely covered by the new one.
-    while (endIndex < this.#segmentsInternal.length && this.#segmentsInternal[endIndex].end <= newSegment.end) {
+    while (endIndex < this.#segments.length && this.#segments[endIndex].end <= newSegment.end) {
       ++endIndex;
     }
     // 4. Merge or adjust the succeeding segment if it overlaps.
-    if (endIndex < this.#segmentsInternal.length) {
-      merged = this.tryMerge(newSegment, this.#segmentsInternal[endIndex]);
+    if (endIndex < this.#segments.length) {
+      merged = this.tryMerge(newSegment, this.#segments[endIndex]);
       if (merged) {
         endIndex++;
         newSegment = merged;
-      } else if (newSegment.intersects(this.#segmentsInternal[endIndex])) {
-        this.#segmentsInternal[endIndex].begin = newSegment.end;
+      } else if (newSegment.intersects(this.#segments[endIndex])) {
+        this.#segments[endIndex].begin = newSegment.end;
       }
     }
-    this.#segmentsInternal.splice(startIndex, endIndex - startIndex, newSegment);
+    this.#segments.splice(startIndex, endIndex - startIndex, newSegment);
   }
 
   segments(): Array<Segment<T>> {
-    return this.#segmentsInternal;
+    return this.#segments;
   }
 
   private tryMerge(first: Segment<T>, second: Segment<T>): Segment<T>|null {

package/front_end/core/common/Settings.ts

@@ -354,7 +354,7 @@ export class Deprecation {
 
 export class Setting<V> {
   #titleFunction?: () => Platform.UIString.LocalizedString;
-  #titleInternal!: Platform.UIString.LocalizedString;
+  #title!: Platform.UIString.LocalizedString;
   #registration: SettingRegistration|null = null;
   #requiresUserAction?: boolean;
   #value?: V;
@@ -387,8 +387,8 @@ export class Setting<V> {
   }
 
   title(): Platform.UIString.LocalizedString {
-    if (this.#titleInternal) {
-      return this.#titleInternal;
+    if (this.#title) {
+      return this.#title;
     }
     if (this.#titleFunction) {
       return this.#titleFunction();
@@ -403,7 +403,7 @@ export class Setting<V> {
   }
 
   setTitle(title: Platform.UIString.LocalizedString): void {
-    this.#titleInternal = title;
+    this.#title = title;
   }
 
   setRequiresUserAction(requiresUserAction: boolean): void {

package/front_end/core/common/StringOutputStream.ts

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

package/front_end/core/host/GdpClient.ts

@@ -36,6 +36,11 @@ export enum EmailPreference {
 interface CheckElibigilityResponse {
   createProfile: EligibilityStatus;
 }
+
+interface BatchGetAwardsResponse {
+  awards?: Award[];
+}
+
 export interface Award {
   name: string;
   badge: {
@@ -63,6 +68,18 @@ export interface Profile {
   };
 }
 
+// The `batchGet` awards endpoint returns badge names with an
+// obfuscated user ID (e.g., `profiles/12345/awards/badge-name`).
+// This function normalizes them to use `me` instead of the ID
+// (e.g., `profiles/me/awards/badge-path`) to match the format
+// used for client-side requests.
+function normalizeBadgeName(name: string): string {
+  return name.replace(/profiles\/[^/]+\/awards\//, 'profiles/me/awards/');
+}
+
+// TODO(crbug.com/441679275): Update once the API is enabled for prod.
+export const GOOGLE_DEVELOPER_PROGRAM_PROFILE_LINK = 'https://developers.devsite.corp.google.com/profile/u/me';
+
 async function makeHttpRequest<R extends object>(request: DispatchHttpRequestRequest): Promise<R|null> {
   if (!Root.Runtime.hostConfig.devToolsGdpProfiles?.enabled) {
     return null;
@@ -127,6 +144,27 @@ export class GdpClient {
     return await this.#cachedEligibilityPromise;
   }
 
+  /**
+   * @returns null if the request fails, the awarded badge names otherwise.
+   */
+  async getAwardedBadgeNames({names}: {names: string[]}): Promise<Set<string>|null> {
+    const result = await makeHttpRequest<BatchGetAwardsResponse>({
+      service: SERVICE_NAME,
+      path: '/v1beta1/profiles/me/awards:batchGet',
+      method: 'GET',
+      queryParams: {
+        allowMissing: 'true',
+        names,
+      }
+    });
+
+    if (!result) {
+      return null;
+    }
+
+    return new Set(result.awards?.map(award => normalizeBadgeName(award.name)) ?? []);
+  }
+
   async isEligibleToCreateProfile(): Promise<boolean> {
     return (await this.checkEligibility())?.createProfile === EligibilityStatus.ELIGIBLE;
   }

package/front_end/core/host/InspectorFrontendHost.ts

@@ -423,7 +423,10 @@ export class InspectorFrontendHostStub implements InspectorFrontendHostAPI {
       },
       devToolsIpProtectionPanelInDevTools: {
         enabled: false,
-      }
+      },
+      devToolsFlexibleLayout: {
+        verticalDrawerEnabled: true,
+      },
     };
     if ('hostConfigForTesting' in globalThis) {
       const {hostConfigForTesting} = (globalThis as unknown as {hostConfigForTesting: Root.Runtime.HostConfig});

package/front_end/core/host/InspectorFrontendHostAPI.ts

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

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/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 {