chrome-devtools-frontend 1.0.1661063 → 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/CompilerScriptMapping.ts

@@ -55,9 +55,9 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
     this.#debuggerModel = debuggerModel;
     this.#ignoreListManager = debuggerWorkspaceBinding.ignoreListManager;
 
-    this.#stubProject = new ContentProviderBasedProject(workspace, 'jsSourceMaps:stub:' + debuggerModel.target().id(),
-                                                        Workspace.Workspace.projectTypes.Service, '',
-                                                        true /* isServiceProject */, debuggerModel.target());
+    this.#stubProject =
+        new ContentProviderBasedProject(workspace, 'jsSourceMaps:stub:' + debuggerModel.target().id(),
+                                        Workspace.Workspace.projectTypes.Service, '', true /* isServiceProject */);
     this.#eventListeners = [
       this.#sourceMapManager.addEventListener(
           SDK.SourceMapManager.Events.SourceMapWillAttach, this.sourceMapWillAttach, this),
@@ -464,7 +464,8 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
       const projectType = script.isContentScript() ? Workspace.Workspace.projectTypes.ContentScripts :
                                                      Workspace.Workspace.projectTypes.Network;
       project = new ContentProviderBasedProject(this.#stubProject.workspace(), projectId, projectType,
-                                                /* displayName */ '', /* isServiceProject */ false, target);
+                                                /* displayName */ '', /* isServiceProject */ false);
+      NetworkProject.setTargetForProject(project, target);
       this.#projects.set(projectId, project);
     }
     this.#sourceMapToProject.set(sourceMap, project);

package/front_end/models/bindings/ContentProviderBasedProject.ts

@@ -5,7 +5,6 @@
 import type * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as Platform from '../../core/platform/platform.js';
-import type * as SDK from '../../core/sdk/sdk.js';
 import * as TextUtils from '../text_utils/text_utils.js';
 import * as Workspace from '../workspace/workspace.js';
 
@@ -28,8 +27,8 @@ export class ContentProviderBasedProject extends Workspace.Workspace.ProjectStor
   readonly #isServiceProject: boolean;
   readonly #uiSourceCodeToData = new WeakMap<Workspace.UISourceCode.UISourceCode, UISourceCodeData>();
   constructor(workspace: Workspace.Workspace.WorkspaceImpl, id: string, type: Workspace.Workspace.projectTypes,
-              displayName: string, isServiceProject: boolean, target: SDK.Target.Target|null = null) {
-    super(workspace, id, type, displayName, target);
+              displayName: string, isServiceProject: boolean) {
+    super(workspace, id, type, displayName);
     this.#isServiceProject = isServiceProject;
     workspace.addProject(this);
   }

package/front_end/models/bindings/DebuggerLanguagePlugins.ts

@@ -1100,9 +1100,10 @@ class ModelData {
   project: ContentProviderBasedProject;
   readonly uiSourceCodeToScripts: Map<Workspace.UISourceCode.UISourceCode, SDK.Script.Script[]>;
   constructor(debuggerModel: SDK.DebuggerModel.DebuggerModel, workspace: Workspace.Workspace.WorkspaceImpl) {
-    this.project = new ContentProviderBasedProject(workspace, 'language_plugins::' + debuggerModel.target().id(),
-                                                   Workspace.Workspace.projectTypes.Network, '',
-                                                   false /* isServiceProject */, debuggerModel.target());
+    this.project =
+        new ContentProviderBasedProject(workspace, 'language_plugins::' + debuggerModel.target().id(),
+                                        Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
+    NetworkProject.setTargetForProject(this.project, debuggerModel.target());
 
     this.uiSourceCodeToScripts = new Map();
   }

package/front_end/models/bindings/DefaultScriptMapping.ts

@@ -23,9 +23,9 @@ export class DefaultScriptMapping implements DebuggerSourceMapping {
       debuggerWorkspaceBinding: DebuggerWorkspaceBinding) {
     defaultScriptMappings.add(this);
     this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
-    this.#project = new ContentProviderBasedProject(workspace, 'debugger:' + debuggerModel.target().id(),
-                                                    Workspace.Workspace.projectTypes.Debugger, '',
-                                                    true /* isServiceProject */, debuggerModel.target());
+    this.#project =
+        new ContentProviderBasedProject(workspace, 'debugger:' + debuggerModel.target().id(),
+                                        Workspace.Workspace.projectTypes.Debugger, '', true /* isServiceProject */);
     this.#eventListeners = [
       debuggerModel.addEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, this.globalObjectCleared, this),
       debuggerModel.addEventListener(SDK.DebuggerModel.Events.ParsedScriptSource, this.parsedScriptSource, this),

package/front_end/models/bindings/NetworkProject.ts

@@ -14,6 +14,7 @@ const uiSourceCodeToAttributionMap = new WeakMap<Workspace.UISourceCode.UISource
                                                  }>>();
 
 export class NetworkProjectManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  readonly #projectToTargetMap = new WeakMap<Workspace.Workspace.Project, SDK.Target.Target>();
 
   static instance({forceNew}: {
     forceNew: boolean,
@@ -28,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 {
@@ -131,7 +144,15 @@ export class NetworkProject {
   }
 
   static targetForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Target.Target|null {
-    return uiSourceCode.project().target();
+    return NetworkProjectManager.instance().getTargetForUISourceCode(uiSourceCode);
+  }
+
+  static setTargetForProject(project: Workspace.Workspace.Project, target: SDK.Target.Target): void {
+    NetworkProjectManager.instance().setTargetForProject(project, target);
+  }
+
+  static getTargetForProject(project: Workspace.Workspace.Project): SDK.Target.Target|null {
+    return NetworkProjectManager.instance().getTargetForProject(project);
   }
 
   static framesForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode):

package/front_end/models/bindings/ResourceMapping.ts

@@ -361,9 +361,10 @@ class ModelInfo {
   constructor(resourceMapping: ResourceMapping, resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel) {
     const target = resourceTreeModel.target();
     this.resourceMapping = resourceMapping;
-    this.project = new ContentProviderBasedProject(resourceMapping.workspace, 'resources:' + target.id(),
-                                                   Workspace.Workspace.projectTypes.Network, '',
-                                                   false /* isServiceProject */, target);
+    this.project =
+        new ContentProviderBasedProject(resourceMapping.workspace, 'resources:' + target.id(),
+                                        Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
+    NetworkProject.setTargetForProject(this.project, target);
 
     const cssModel = target.model(SDK.CSSModel.CSSModel);
     console.assert(Boolean(cssModel));

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -74,7 +74,8 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
       const projectType = script.isContentScript() ? Workspace.Workspace.projectTypes.ContentScripts :
                                                      Workspace.Workspace.projectTypes.Network;
       project = new ContentProviderBasedProject(this.#workspace, projectId, projectType, '' /* displayName */,
-                                                false /* isServiceProject */, this.debuggerModel.target());
+                                                false /* isServiceProject */);
+      NetworkProject.setTargetForProject(project, this.debuggerModel.target());
       this.#projects.set(projectId, project);
     }
     return project;

package/front_end/models/bindings/SASSSourceMapping.ts

@@ -26,9 +26,10 @@ export class SASSSourceMapping implements SourceMapping {
       workspace: Workspace.Workspace.WorkspaceImpl, cssWorkspaceBinding: CSSWorkspaceBinding) {
     this.#sourceMapManager = sourceMapManager;
     this.#cssWorkspaceBinding = cssWorkspaceBinding;
-    this.#project = new ContentProviderBasedProject(workspace, 'cssSourceMaps:' + target.id(),
-                                                    Workspace.Workspace.projectTypes.Network, '',
-                                                    false /* isServiceProject */, target);
+    this.#project =
+        new ContentProviderBasedProject(workspace, 'cssSourceMaps:' + target.id(),
+                                        Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
+    NetworkProject.setTargetForProject(this.#project, target);
 
     this.#bindings = new Map();
 

package/front_end/models/bindings/StylesSourceMapping.ts

@@ -24,9 +24,9 @@ export class StylesSourceMapping implements SourceMapping {
   constructor(cssModel: SDK.CSSModel.CSSModel, workspace: Workspace.Workspace.WorkspaceImpl) {
     this.#cssModel = cssModel;
     const target = this.#cssModel.target();
-    this.#project =
-        new ContentProviderBasedProject(workspace, 'css:' + target.id(), Workspace.Workspace.projectTypes.Network, '',
-                                        false /* isServiceProject */, target);
+    this.#project = new ContentProviderBasedProject(
+        workspace, 'css:' + target.id(), Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
+    NetworkProject.setTargetForProject(this.#project, target);
 
     this.#eventListeners = [
       this.#cssModel.addEventListener(SDK.CSSModel.Events.StyleSheetAdded, this.styleSheetAdded, this),

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/RecorderExtensionEndpoint.ts

@@ -6,22 +6,24 @@ import type * as Platform from '../../core/platform/platform.js';
 
 import {PrivateAPI} from './ExtensionAPI.js';
 import {ExtensionEndpoint} from './ExtensionEndpoint.js';
-import {RecorderPluginManager} from './RecorderPluginManager.js';
+import type {RecorderPluginManager} from './RecorderPluginManager.js';
 
 export class RecorderExtensionEndpoint extends ExtensionEndpoint {
   private readonly name: string;
   private readonly mediaType?: string;
   private readonly capabilities: PrivateAPI.RecordingExtensionPluginCapability[];
   readonly #extensionOrigin: Platform.DevToolsPath.UrlString;
+  readonly #recorderPluginManager: RecorderPluginManager;
 
-  constructor(
-      name: string, port: MessagePort, capabilities: PrivateAPI.RecordingExtensionPluginCapability[],
-      extensionOrigin: Platform.DevToolsPath.UrlString, mediaType?: string) {
+  constructor(name: string, port: MessagePort, capabilities: PrivateAPI.RecordingExtensionPluginCapability[],
+              extensionOrigin: Platform.DevToolsPath.UrlString, recorderPluginManager: RecorderPluginManager,
+              mediaType?: string) {
     super(port);
     this.name = name;
     this.mediaType = mediaType;
     this.capabilities = capabilities;
     this.#extensionOrigin = extensionOrigin;
+    this.#recorderPluginManager = recorderPluginManager;
   }
 
   getName(): string {
@@ -44,7 +46,7 @@ export class RecorderExtensionEndpoint extends ExtensionEndpoint {
     switch (event) {
       case PrivateAPI.RecorderExtensionPluginEvents.UnregisteredRecorderExtensionPlugin: {
         this.disconnect();
-        RecorderPluginManager.instance().removePlugin(this);
+        this.#recorderPluginManager.removePlugin(this);
         break;
       }
       default:

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