chrome-devtools-frontend 1.0.1662289 → 1.0.1662965

package/front_end/models/badges/UserBadges.ts

@@ -4,6 +4,7 @@
 
 import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
+import * as Root from '../../core/root/root.js';
 
 import {AiExplorerBadge} from './AiExplorerBadge.js';
 import type {Badge, BadgeAction, BadgeActionEvents, BadgeContext, TriggerOptions} from './Badge.js';
@@ -32,7 +33,6 @@ const SNOOZE_TIME_MS = 24 * 60 * 60 * 1000;  // 24 hours
 const MAX_SNOOZE_COUNT = 3;
 const DELAY_BEFORE_TRIGGER = 1500;
 
-let userBadgesInstance: UserBadges|undefined = undefined;
 export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #badgeActionEventTarget = new Common.ObjectWrapper.ObjectWrapper<BadgeActionEvents>();
 
@@ -43,6 +43,9 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   #starterBadgeLastSnoozedTimestamp: Common.Settings.Setting<number>;
   #starterBadgeDismissed: Common.Settings.Setting<boolean>;
 
+  readonly #settings: Common.Settings.Settings;
+  readonly #gdpClient: Host.GdpClient.GdpClient;
+
   static readonly BADGE_REGISTRY: BadgeClass[] = [
     StarterBadge,
     SpeedsterBadge,
@@ -51,21 +54,27 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     AiExplorerBadge,
   ];
 
-  private constructor() {
+  constructor(
+      settings: Common.Settings.Settings,
+      gdpClient: Host.GdpClient.GdpClient,
+  ) {
     super();
 
-    this.#receiveBadgesSetting = Common.Settings.Settings.instance().moduleSetting('receive-gdp-badges');
+    this.#settings = settings;
+    this.#gdpClient = gdpClient;
+
+    this.#receiveBadgesSetting = this.#settings.moduleSetting('receive-gdp-badges');
     if (!Host.GdpClient.isBadgesEnabled()) {
       this.#receiveBadgesSetting.set(false);
     }
     this.#receiveBadgesSetting.addChangeListener(this.#reconcileBadges, this);
 
-    this.#starterBadgeSnoozeCount = Common.Settings.Settings.instance().createSetting(
-        'starter-badge-snooze-count', 0, Common.Settings.SettingStorageType.SYNCED);
-    this.#starterBadgeLastSnoozedTimestamp = Common.Settings.Settings.instance().createSetting(
-        'starter-badge-last-snoozed-timestamp', 0, Common.Settings.SettingStorageType.SYNCED);
-    this.#starterBadgeDismissed = Common.Settings.Settings.instance().createSetting(
-        'starter-badge-dismissed', false, Common.Settings.SettingStorageType.SYNCED);
+    this.#starterBadgeSnoozeCount =
+        this.#settings.createSetting('starter-badge-snooze-count', 0, Common.Settings.SettingStorageType.SYNCED);
+    this.#starterBadgeLastSnoozedTimestamp = this.#settings.createSetting('starter-badge-last-snoozed-timestamp', 0,
+                                                                          Common.Settings.SettingStorageType.SYNCED);
+    this.#starterBadgeDismissed =
+        this.#settings.createSetting('starter-badge-dismissed', false, Common.Settings.SettingStorageType.SYNCED);
 
     this.#allBadges = UserBadges.BADGE_REGISTRY.map(badgeCtor => new badgeCtor({
                                                       onTriggerBadge: this.#onTriggerBadge.bind(this),
@@ -74,10 +83,16 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   }
 
   static instance({forceNew}: {forceNew: boolean} = {forceNew: false}): UserBadges {
-    if (!userBadgesInstance || forceNew) {
-      userBadgesInstance = new UserBadges();
+    if (!Root.DevToolsContext.globalInstance().has(UserBadges) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(
+          UserBadges,
+          new UserBadges(
+              Common.Settings.Settings.instance(),
+              Host.GdpClient.GdpClient.instance(),
+              ),
+      );
     }
-    return userBadgesInstance;
+    return Root.DevToolsContext.globalInstance().get(UserBadges);
   }
 
   async initialize(): Promise<void> {
@@ -108,7 +123,7 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
       return BadgeTriggerReason.AWARD;
     }
 
-    const getProfileResponse = await Host.GdpClient.GdpClient.instance().getProfile();
+    const getProfileResponse = await this.#gdpClient.getProfile();
     // The `getProfile` call failed and returned a `null`.
     // For that case, we don't show anything.
     if (!getProfileResponse) {
@@ -147,7 +162,7 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     }
 
     if (reason === BadgeTriggerReason.AWARD) {
-      const result = await Host.GdpClient.GdpClient.instance().createAward({name: badge.name});
+      const result = await this.#gdpClient.createAward({name: badge.name});
       if (!result) {
         return;
       }
@@ -192,7 +207,7 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
       return;
     }
 
-    const getProfileResponse = await Host.GdpClient.GdpClient.instance().getProfile();
+    const getProfileResponse = await this.#gdpClient.getProfile();
     if (!getProfileResponse) {
       this.#deactivateAllBadges();
       return;
@@ -209,8 +224,7 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
 
     let awardedBadgeNames: Set<string>|null = null;
     if (hasGdpProfile) {
-      awardedBadgeNames = await Host.GdpClient.GdpClient.instance().getAwardedBadgeNames(
-          {names: this.#allBadges.map(badge => badge.name)});
+      awardedBadgeNames = await this.#gdpClient.getAwardedBadgeNames({names: this.#allBadges.map(badge => badge.name)});
       // This is a conservative approach. We bail out if `awardedBadgeNames` is null
       // when there is a profile to prevent a negative user experience.
       //

package/front_end/models/bindings/NetworkProject.ts

@@ -12,9 +12,9 @@ const uiSourceCodeToAttributionMap = new WeakMap<Workspace.UISourceCode.UISource
                                                    frame: SDK.ResourceTreeModel.ResourceTreeFrame,
                                                    count: number,
                                                  }>>();
-const projectToTargetMap = new WeakMap<Workspace.Workspace.Project, SDK.Target.Target>();
 
 export class NetworkProjectManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  readonly #projectToTargetMap = new WeakMap<Workspace.Workspace.Project, SDK.Target.Target>();
 
   static instance({forceNew}: {
     forceNew: boolean,
@@ -29,6 +29,18 @@ export class NetworkProjectManager extends Common.ObjectWrapper.ObjectWrapper<Ev
   static removeInstance(): void {
     Root.DevToolsContext.globalInstance().delete(NetworkProjectManager);
   }
+
+  setTargetForProject(project: Workspace.Workspace.Project, target: SDK.Target.Target): void {
+    this.#projectToTargetMap.set(project, target);
+  }
+
+  getTargetForProject(project: Workspace.Workspace.Project): SDK.Target.Target|null {
+    return this.#projectToTargetMap.get(project) ?? null;
+  }
+
+  getTargetForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Target.Target|null {
+    return this.#projectToTargetMap.get(uiSourceCode.project()) ?? null;
+  }
 }
 
 export const enum Events {
@@ -132,15 +144,15 @@ export class NetworkProject {
   }
 
   static targetForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Target.Target|null {
-    return projectToTargetMap.get(uiSourceCode.project()) || null;
+    return NetworkProjectManager.instance().getTargetForUISourceCode(uiSourceCode);
   }
 
   static setTargetForProject(project: Workspace.Workspace.Project, target: SDK.Target.Target): void {
-    projectToTargetMap.set(project, target);
+    NetworkProjectManager.instance().setTargetForProject(project, target);
   }
 
   static getTargetForProject(project: Workspace.Workspace.Project): SDK.Target.Target|null {
-    return projectToTargetMap.get(project) || null;
+    return NetworkProjectManager.instance().getTargetForProject(project);
   }
 
   static framesForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode):

package/front_end/models/emulation/DeviceModeModel.ts

@@ -11,6 +11,8 @@ import * as Protocol from '../../generated/protocol.js';
 import * as Geometry from '../geometry/geometry.js';
 
 import {
+  type Cutout,
+  CutoutShape,
   type EmulatedDevice,
   Horizontal,
   HorizontalSpanned,
@@ -85,6 +87,13 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('models/emulation/DeviceModeModel.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
+const CUTOUT_SHAPE_TO_PROTOCOL: Record<CutoutShape, Protocol.Overlay.DisplayCutoutShape> = {
+  [CutoutShape.PILL]: Protocol.Overlay.DisplayCutoutShape.Pill,
+  [CutoutShape.NOTCH]: Protocol.Overlay.DisplayCutoutShape.Notch,
+  [CutoutShape.CIRCLE]: Protocol.Overlay.DisplayCutoutShape.Circle,
+  [CutoutShape.RECTANGLE]: Protocol.Overlay.DisplayCutoutShape.Rectangle,
+};
+
 export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDK.TargetManager.SDKModelObserver<SDK.EmulationModel.EmulationModel> {
   #screenRect: Rect;
@@ -506,7 +515,7 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
       return;
     }
 
-    this.showHingeIfApplicable(overlayModel);
+    this.showDeviceOverlaysIfApplicable(overlayModel);
   }
 
   private onScreenOrientationLockChanged(
@@ -638,7 +647,7 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     const mobile = this.isMobile();
     const overlayModel = this.#emulationModel ? this.#emulationModel.overlayModel() : null;
     if (overlayModel) {
-      this.showHingeIfApplicable(overlayModel);
+      this.showDeviceOverlaysIfApplicable(overlayModel);
     }
     if (this.#type === Type.Device && this.#device && this.#mode) {
       const orientation = this.#device.orientationByName(this.#mode.orientation);
@@ -878,14 +887,67 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     }
   }
 
-  private showHingeIfApplicable(overlayModel: SDK.OverlayModel.OverlayModel): void {
+  private showDeviceOverlaysIfApplicable(overlayModel: SDK.OverlayModel.OverlayModel): void {
     const orientation = (this.#device && this.#mode) ? this.#device.orientationByName(this.#mode.orientation) : null;
     if (orientation?.hinge) {
       overlayModel.showHingeForDualScreen(orientation.hinge);
-      return;
+    } else {
+      overlayModel.showHingeForDualScreen(null);
+    }
+
+    overlayModel.showDisplayCutout(this.currentDisplayCutout());
+  }
+
+  private currentDisplayCutout(): SDK.OverlayModel.DisplayCutout|null {
+    const device = this.#device;
+    const mode = this.#mode;
+    if (!device || !mode || !device.modes.includes(mode)) {
+      return null;
+    }
+
+    const cutout = mode.cutout;
+    if (cutout) {
+      return this.toDisplayCutout(cutout);
     }
 
-    overlayModel.showHingeForDualScreen(null);
+    if (mode.orientation !== Horizontal) {
+      return null;
+    }
+
+    const rotationPartner = device.getRotationPartner(mode);
+    const rotatedCutout = rotationPartner?.cutout;
+    if (rotationPartner?.orientation !== Vertical || !rotatedCutout) {
+      return null;
+    }
+
+    const orientation = device.orientationByName(mode.orientation);
+    if (rotatedCutout.shape === CutoutShape.CIRCLE) {
+      return this.toDisplayCutout({
+        ...rotatedCutout,
+        x: orientation.width - rotatedCutout.y - rotatedCutout.height,
+        y: rotatedCutout.x,
+        width: rotatedCutout.height,
+        height: rotatedCutout.width,
+        cx: orientation.width - rotatedCutout.cy,
+        cy: rotatedCutout.cx,
+      });
+    }
+    return this.toDisplayCutout({
+      ...rotatedCutout,
+      x: orientation.width - rotatedCutout.y - rotatedCutout.height,
+      y: rotatedCutout.x,
+      width: rotatedCutout.height,
+      height: rotatedCutout.width,
+    });
+  }
+
+  private toDisplayCutout(cutout: Cutout): SDK.OverlayModel.DisplayCutout {
+    const {shape, ...rest} = cutout;
+    return {
+      ...rest,
+      shape: CUTOUT_SHAPE_TO_PROTOCOL[shape],
+      contentColor: {r: 0, g: 0, b: 0, a: 1},
+    } as SDK.OverlayModel.DisplayCutout;
   }
 
   private getDisplayFeatureOrientation(): Protocol.Emulation.DisplayFeatureOrientation {

package/front_end/models/extensions/RecorderPluginManager.ts

@@ -3,11 +3,10 @@
 // found in the LICENSE file.
 
 import * as Common from '../../core/common/common.js';
+import * as Root from '../../core/root/root.js';
 
 import type {RecorderExtensionEndpoint} from './RecorderExtensionEndpoint.js';
 
-let instance: RecorderPluginManager|null = null;
-
 export interface ViewDescriptor {
   id: string;
   title: string;
@@ -21,11 +20,16 @@ export class RecorderPluginManager extends Common.ObjectWrapper.ObjectWrapper<Ev
   #plugins = new Set<RecorderExtensionEndpoint>();
   #views = new Map<string, ViewDescriptor>();
 
-  static instance(): RecorderPluginManager {
-    if (!instance) {
-      instance = new RecorderPluginManager();
+  static instance(opts?: {forceNew: boolean}): RecorderPluginManager {
+    if (!Root.DevToolsContext.globalInstance().has(RecorderPluginManager) || opts?.forceNew) {
+      Root.DevToolsContext.globalInstance().set(RecorderPluginManager, new RecorderPluginManager());
     }
-    return instance;
+
+    return Root.DevToolsContext.globalInstance().get(RecorderPluginManager);
+  }
+
+  static removeInstance(): void {
+    Root.DevToolsContext.globalInstance().delete(RecorderPluginManager);
   }
 
   addPlugin(plugin: RecorderExtensionEndpoint): void {

package/front_end/models/har/Log.snapshot.txt

@@ -0,0 +1,193 @@
+Title: HAR Log build converts network requests into a complete HAR log with pages and entries
+Content:
+{
+  "version": "1.2",
+  "creator": {
+    "name": "WebInspector",
+    "version": "VERSION"
+  },
+  "pages": [
+    {
+      "startedDateTime": "1970-01-01T00:00:01.000Z",
+      "id": "page_1",
+      "title": "http://127.0.0.1:8000/devtools/resources/inspected-page.html",
+      "pageTimings": {
+        "onContentLoad": 9000,
+        "onLoad": 14000
+      }
+    }
+  ],
+  "entries": [
+    {
+      "_initiator": null,
+      "_priority": null,
+      "_resourceType": "document",
+      "cache": {},
+      "request": {
+        "method": "GET",
+        "url": "http://127.0.0.1:8000/devtools/resources/inspected-page.html",
+        "httpVersion": "HTTP/1.1",
+        "headers": [
+          {
+            "name": "version",
+            "value": "HTTP/1.1"
+          }
+        ],
+        "queryString": [],
+        "cookies": [
+          {
+            "name": "a",
+            "value": "b",
+            "path": "/path",
+            "domain": "example.com",
+            "expires": null,
+            "httpOnly": false,
+            "secure": false
+          },
+          {
+            "name": "a1",
+            "value": "b1",
+            "expires": null,
+            "httpOnly": false,
+            "secure": false
+          },
+          {
+            "name": "c1",
+            "value": "d1",
+            "expires": null,
+            "httpOnly": false,
+            "secure": false
+          }
+        ],
+        "headersSize": -1,
+        "bodySize": 0
+      },
+      "response": {
+        "status": 0,
+        "statusText": "",
+        "httpVersion": "",
+        "headers": [
+          {
+            "name": "Set-Cookie",
+            "value": "x=y; Path=/path; Domain=example.com; httpOnly; Secure\nx1=y1; SameSite=Strict\nz2=y2; SameSite=Lax"
+          }
+        ],
+        "cookies": [
+          {
+            "name": "x",
+            "value": "y",
+            "path": "/path",
+            "domain": "example.com",
+            "expires": null,
+            "httpOnly": true,
+            "secure": true
+          },
+          {
+            "name": "x1",
+            "value": "y1",
+            "domain": "127.0.0.1",
+            "expires": null,
+            "httpOnly": false,
+            "secure": false,
+            "sameSite": "Strict"
+          },
+          {
+            "name": "z2",
+            "value": "y2",
+            "domain": "127.0.0.1",
+            "expires": null,
+            "httpOnly": false,
+            "secure": false,
+            "sameSite": "Lax"
+          }
+        ],
+        "content": {
+          "size": 0,
+          "mimeType": "x-unknown"
+        },
+        "redirectURL": "",
+        "headersSize": -1,
+        "bodySize": -1,
+        "_transferSize": 0,
+        "_error": null,
+        "_fetchedViaServiceWorker": true,
+        "_responseCacheStorageCacheName": "v1",
+        "_serviceWorkerResponseSource": "cache-storage",
+        "_serviceWorkerRouterRuleIdMatched": 3,
+        "_serviceWorkerRouterMatchedSourceType": "cache",
+        "_serviceWorkerRouterActualSourceType": "cache"
+      },
+      "serverIPAddress": "",
+      "startedDateTime": "1969-12-31T23:59:59.000Z",
+      "time": 0,
+      "timings": {
+        "blocked": 0,
+        "dns": -1,
+        "ssl": -1,
+        "connect": -1,
+        "send": 0,
+        "wait": 0,
+        "receive": 0,
+        "_blocked_queueing": 2000
+      },
+      "pageref": "page_1"
+    },
+    {
+      "_initiator": null,
+      "_priority": null,
+      "_resourceType": "xhr",
+      "cache": {},
+      "request": {
+        "method": "POST",
+        "url": "http://127.0.0.1:8000/devtools/resources/post-target.cgi",
+        "httpVersion": "",
+        "headers": [
+          {
+            "name": "Content-Type",
+            "value": "text/xml"
+          }
+        ],
+        "queryString": [],
+        "cookies": [],
+        "headersSize": -1,
+        "bodySize": 11,
+        "postData": {
+          "mimeType": "text/xml",
+          "text": "<xml></xml>"
+        }
+      },
+      "response": {
+        "status": 0,
+        "statusText": "",
+        "httpVersion": "",
+        "headers": [],
+        "cookies": [],
+        "content": {
+          "size": 0,
+          "mimeType": "application/xml"
+        },
+        "redirectURL": "",
+        "headersSize": -1,
+        "bodySize": -1,
+        "_transferSize": 0,
+        "_error": null,
+        "_fetchedViaServiceWorker": false
+      },
+      "serverIPAddress": "",
+      "startedDateTime": "1969-12-31T23:59:59.000Z",
+      "time": 0,
+      "timings": {
+        "blocked": 0,
+        "dns": -1,
+        "ssl": -1,
+        "connect": -1,
+        "send": 0,
+        "wait": 0,
+        "receive": 0,
+        "_blocked_queueing": -1
+      },
+      "pageref": "page_1"
+    }
+  ]
+}
+=== end content

package/front_end/models/har/Log.ts

@@ -9,7 +9,7 @@
 // See https://bugs.webkit.org/show_bug.cgi?id=58127 for details.
 
 import * as Common from '../../core/common/common.js';
-import type * as Platform from '../../core/platform/platform.js';
+import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 
@@ -33,7 +33,8 @@ export class Log {
   }
 
   private creator(): Creator {
-    const webKitVersion = /AppleWebKit\/([^ ]+)/.exec(window.navigator.userAgent);
+    const userAgent = Platform.HostRuntime.HOST_RUNTIME.getUserAgent();
+    const webKitVersion = /AppleWebKit\/([^ ]+)/.exec(userAgent);
 
     return {name: 'WebInspector', version: webKitVersion ? webKitVersion[1] : 'n/a'};
   }

package/front_end/models/source_map_scopes/FunctionCodeResolver.ts

@@ -216,14 +216,15 @@ function createFunctionCode(
  */
 export async function getFunctionCodeFromLocation(
     target: SDK.Target.Target, url: Platform.DevToolsPath.UrlString, line: number, column: number,
-    options?: CreateFunctionCodeOptions): Promise<FunctionCode|null> {
+    options?: CreateFunctionCodeOptions,
+    debuggerWorkspaceBinding =
+        Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance()): Promise<FunctionCode|null> {
   const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
   if (!debuggerModel) {
     throw new Error('missing debugger model');
   }
 
   let uiSourceCode: Workspace.UISourceCode.UISourceCode|null = null;
-  const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
   const projects = debuggerWorkspaceBinding.workspace.projectsForType(Workspace.Workspace.projectTypes.Network);
   for (const project of projects) {
     if (Bindings.NetworkProject.NetworkProject.getTargetForProject(project) !== target) {
@@ -245,7 +246,7 @@ export async function getFunctionCodeFromLocation(
     return null;
   }
 
-  return await getFunctionCodeFromRawLocation(rawLocation, options);
+  return await getFunctionCodeFromRawLocation(rawLocation, options, debuggerWorkspaceBinding);
 }
 
 async function format(uiSourceCode: Workspace.UISourceCode.UISourceCode, content: string,
@@ -264,8 +265,9 @@ async function format(uiSourceCode: Workspace.UISourceCode.UISourceCode, content
  * Returns a {@link FunctionCode} for the given raw location.
  */
 export async function getFunctionCodeFromRawLocation(
-    rawLocation: SDK.DebuggerModel.Location, options?: CreateFunctionCodeOptions): Promise<FunctionCode|null> {
-  const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
+    rawLocation: SDK.DebuggerModel.Location, options?: CreateFunctionCodeOptions,
+    debuggerWorkspaceBinding =
+        Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance()): Promise<FunctionCode|null> {
   const functionBounds = await debuggerWorkspaceBinding.functionBoundsAtRawLocation(rawLocation);
   if (!functionBounds) {
     return null;