chrome-devtools-frontend 1.0.1652307 → 1.0.1656291

package/front_end/core/sdk/ConsoleModel.ts

@@ -71,6 +71,7 @@ const str_ = i18n.i18n.registerUIStrings('core/sdk/ConsoleModel.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
 export class ConsoleModel extends SDKModel<EventTypes> {
+  readonly #console: Common.Console.Console;
   #messages: ConsoleMessage[] = [];
   readonly #messagesByTimestamp = new Platform.MapUtilities.Multimap<number, ConsoleMessage>();
   readonly #messageByExceptionId = new Map<RuntimeModel, Map<number, ConsoleMessage>>();
@@ -82,6 +83,7 @@ export class ConsoleModel extends SDKModel<EventTypes> {
 
   constructor(target: Target) {
     super(target);
+    this.#console = target.targetManager().getConsole();
 
     const resourceTreeModel = target.model(ResourceTreeModel);
     if (!resourceTreeModel || resourceTreeModel.cachedResourcesLoaded()) {
@@ -159,7 +161,7 @@ export class ConsoleModel extends SDKModel<EventTypes> {
     if ('error' in result) {
       return;
     }
-    await Common.Console.Console.instance().showPromise();
+    await this.#console.showPromise();
     this.dispatchEventToListeners(
         Events.CommandEvaluated,
         {result: result.object, commandMessage: originatingMessage, exceptionDetails: result.exceptionDetails});
@@ -297,9 +299,9 @@ export class ConsoleModel extends SDKModel<EventTypes> {
     if (settings.moduleSetting('preserve-console-log').get()) {
       const {frame} = event.data;
       if (frame.backForwardCacheDetails.restoredFromCache) {
-        Common.Console.Console.instance().log(i18nString(UIStrings.bfcacheNavigation, {PH1: frame.url}));
+        this.#console.log(i18nString(UIStrings.bfcacheNavigation, {PH1: frame.url}));
       } else {
-        Common.Console.Console.instance().log(i18nString(UIStrings.navigatedToS, {PH1: frame.url}));
+        this.#console.log(i18nString(UIStrings.navigatedToS, {PH1: frame.url}));
       }
     }
   }
@@ -418,6 +420,14 @@ export class ConsoleModel extends SDKModel<EventTypes> {
 
   async saveToTempVariable(currentExecutionContext: ExecutionContext|null, remoteObject: RemoteObject|null):
       Promise<void> {
+    const failedToSave = (result: RemoteObject|null): void => {
+      let message = i18nString(UIStrings.failedToSaveToTempVariable);
+      if (result) {
+        message = (message + ' ' + result.description as Common.UIString.LocalizedString);
+      }
+      this.#console.error(message);
+    };
+
     if (!remoteObject || !currentExecutionContext) {
       failedToSave(null);
       return;
@@ -456,14 +466,6 @@ export class ConsoleModel extends SDKModel<EventTypes> {
       this[name] = value;
       return name;
     }
-
-    function failedToSave(result: RemoteObject|null): void {
-      let message = i18nString(UIStrings.failedToSaveToTempVariable);
-      if (result) {
-        message = (message + ' ' + result.description as Common.UIString.LocalizedString);
-      }
-      Common.Console.Console.instance().error(message);
-    }
   }
 }
 

package/front_end/core/sdk/DOMDebuggerModel.ts

@@ -6,6 +6,7 @@ import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
 import type * as Common from '../common/common.js';
 import * as Platform from '../platform/platform.js';
+import * as Root from '../root/root.js';
 
 import {CategorizedBreakpoint, Category} from './CategorizedBreakpoint.js';
 import type {EventListenerPausedDetailsAuxData, Location} from './DebuggerModel.js';
@@ -528,8 +529,6 @@ export class DOMEventListenerBreakpoint extends CategorizedBreakpoint {
   static readonly listener = 'listener:';
 }
 
-let domDebuggerManagerInstance: DOMDebuggerManager;
-
 export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   readonly #xhrBreakpointsSetting: Common.Settings.Setting<Array<{url: string, enabled: boolean}>>;
   readonly #xhrBreakpoints = new Map<string, boolean>();
@@ -671,11 +670,18 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
     targetManager?: TargetManager,
   } = {forceNew: null}): DOMDebuggerManager {
     const {forceNew, targetManager} = opts;
-    if (!domDebuggerManagerInstance || forceNew) {
-      domDebuggerManagerInstance = new DOMDebuggerManager(targetManager);
+    if (!Root.DevToolsContext.globalInstance().has(DOMDebuggerManager) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(
+          DOMDebuggerManager,
+          new DOMDebuggerManager(targetManager ?? TargetManager.instance()),
+      );
     }
 
-    return domDebuggerManagerInstance;
+    return Root.DevToolsContext.globalInstance().get(DOMDebuggerManager);
+  }
+
+  static removeInstance(): void {
+    Root.DevToolsContext.globalInstance().delete(DOMDebuggerManager);
   }
 
   cspViolationBreakpoints(): CSPViolationBreakpoint[] {

package/front_end/core/sdk/DOMModel.ts

@@ -512,6 +512,10 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
     return this.#pseudoElements.get(Protocol.DOM.PseudoType.PickerIcon)?.at(-1);
   }
 
+  interestButtonPseudoElement(): DOMNode|undefined {
+    return this.#pseudoElements.get(Protocol.DOM.PseudoType.InterestButton)?.at(-1);
+  }
+
   markerPseudoElement(): DOMNode|undefined {
     return this.#pseudoElements.get(Protocol.DOM.PseudoType.Marker)?.at(-1);
   }

package/front_end/core/sdk/EmulationModel.ts

@@ -250,6 +250,10 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
     }
   }
 
+  async setSafeAreaInsets(insets: Protocol.Emulation.SafeAreaInsets): Promise<void> {
+    await this.#emulationAgent.invoke_setSafeAreaInsetsOverride({insets});
+  }
+
   overlayModel(): OverlayModel|null {
     return this.#overlayModel;
   }

package/front_end/core/sdk/EventBreakpointsModel.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Root from '../../core/root/root.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 
 import {CategorizedBreakpoint, Category} from './CategorizedBreakpoint.js';
@@ -83,8 +84,6 @@ class EventListenerBreakpoint extends CategorizedBreakpoint {
   static readonly instrumentationPrefix = 'instrumentation:';
 }
 
-let eventBreakpointManagerInstance: EventBreakpointsManager;
-
 export class EventBreakpointsManager implements SDKModelObserver<EventBreakpointsModel> {
   readonly #eventListenerBreakpoints: EventListenerBreakpoint[] = [];
   readonly #targetManager: TargetManager;
@@ -151,11 +150,16 @@ export class EventBreakpointsManager implements SDKModelObserver<EventBreakpoint
     targetManager?: TargetManager,
   } = {forceNew: null}): EventBreakpointsManager {
     const {forceNew, targetManager} = opts;
-    if (!eventBreakpointManagerInstance || forceNew) {
-      eventBreakpointManagerInstance = new EventBreakpointsManager(targetManager);
+    if (!Root.DevToolsContext.globalInstance().has(EventBreakpointsManager) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(EventBreakpointsManager,
+                                                new EventBreakpointsManager(targetManager ?? TargetManager.instance()));
     }
 
-    return eventBreakpointManagerInstance;
+    return Root.DevToolsContext.globalInstance().get(EventBreakpointsManager);
+  }
+
+  static removeInstance(): void {
+    Root.DevToolsContext.globalInstance().delete(EventBreakpointsManager);
   }
 
   private createInstrumentationBreakpoints(category: Category, instrumentationNames: InstrumentationNames[]): void {

package/front_end/core/sdk/IsolateManager.ts

@@ -3,13 +3,12 @@
 // found in the LICENSE file.
 
 import * as Common from '../common/common.js';
+import * as Root from '../root/root.js';
 
 import type {HeapProfilerModel} from './HeapProfilerModel.js';
 import {RuntimeModel} from './RuntimeModel.js';
 import {type SDKModelObserver, TargetManager} from './TargetManager.js';
 
-let isolateManagerInstance: IsolateManager;
-
 export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<RuntimeModel> {
   readonly #isolates = new Map<string, Isolate>();
@@ -28,15 +27,16 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
     this.#targetManager.observeModels(RuntimeModel, this);
   }
 
-  static instance({forceNew, targetManager}: {
+  static instance(opts: {
     forceNew: boolean,
     targetManager?: TargetManager,
   } = {forceNew: false}): IsolateManager {
-    if (!isolateManagerInstance || forceNew) {
-      isolateManagerInstance = new IsolateManager(targetManager);
+    const {forceNew, targetManager} = opts;
+    if (!Root.DevToolsContext.globalInstance().has(IsolateManager) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(IsolateManager, new IsolateManager(targetManager));
     }
 
-    return isolateManagerInstance;
+    return Root.DevToolsContext.globalInstance().get(IsolateManager);
   }
 
   observeIsolates(observer: Observer): void {

package/front_end/core/sdk/ResourceTreeModel.ts

@@ -9,7 +9,7 @@ import * as i18n from '../i18n/i18n.js';
 import * as Platform from '../platform/platform.js';
 
 import {type DeferredDOMNode, DOMModel, type DOMNode} from './DOMModel.js';
-import {FrameManager} from './FrameManager.js';
+import type {FrameManager} from './FrameManager.js';
 import {Events as NetworkManagerEvents, NetworkManager, type RequestUpdateDroppedEventData} from './NetworkManager.js';
 import type {NetworkRequest} from './NetworkRequest.js';
 import {Resource} from './Resource.js';
@@ -25,6 +25,7 @@ export class ResourceTreeModel extends SDKModel<EventTypes> {
   readonly storageAgent: ProtocolProxyApi.StorageApi;
   readonly #securityOriginManager: SecurityOriginManager;
   readonly #storageKeyManager: StorageKeyManager;
+  readonly #frameManager: FrameManager;
   readonly framesInternal = new Map<string, ResourceTreeFrame>();
   #cachedResourcesProcessed = false;
   #pendingReloadOptions: {
@@ -38,6 +39,7 @@ export class ResourceTreeModel extends SDKModel<EventTypes> {
 
   constructor(target: Target) {
     super(target);
+    this.#frameManager = target.targetManager().getFrameManager();
 
     const networkManager = target.model(NetworkManager);
     if (networkManager) {
@@ -92,8 +94,9 @@ export class ResourceTreeModel extends SDKModel<EventTypes> {
     return null;
   }
 
-  static reloadAllPages(bypassCache?: boolean, scriptToEvaluateOnLoad?: string): void {
-    for (const resourceTreeModel of TargetManager.instance().models(ResourceTreeModel)) {
+  static reloadAllPages(bypassCache?: boolean, scriptToEvaluateOnLoad?: string,
+                        targetManager: TargetManager = TargetManager.instance()): void {
+    for (const resourceTreeModel of targetManager.models(ResourceTreeModel)) {
       if (resourceTreeModel.target().parentTarget()?.type() !== Type.FRAME) {
         resourceTreeModel.reloadPage(bypassCache, scriptToEvaluateOnLoad);
       }
@@ -215,8 +218,8 @@ export class ResourceTreeModel extends SDKModel<EventTypes> {
     void this.updateStorageKeys();
 
     if (frame.backForwardCacheDetails.restoredFromCache) {
-      FrameManager.instance().modelRemoved(this);
-      FrameManager.instance().modelAdded(this);
+      this.#frameManager.modelRemoved(this);
+      this.#frameManager.modelAdded(this);
       void this.#buildResourceTree();
     }
   }

package/front_end/core/sdk/TargetManager.ts

@@ -10,6 +10,7 @@ import {assertNotNullOrUndefined} from '../platform/platform.js';
 import type * as ProtocolClient from '../protocol_client/protocol_client.js';
 import * as Root from '../root/root.js';
 
+import {FrameManager} from './FrameManager.js';
 import {type RegistrationInfo, SDKModel, type SDKModelConstructor} from './SDKModel.js';
 import {Target, Type as TargetType} from './Target.js';
 
@@ -31,6 +32,22 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
     return this.context.get(Common.Settings.Settings);
   }
 
+  // TODO(crbug.com/493763857): Remove fallback once all unit tests use TestUniverse.
+  getConsole(): Common.Console.Console {
+    if ('has' in this.context && typeof this.context.has === 'function' && !this.context.has(Common.Console.Console)) {
+      return Common.Console.Console.instance();
+    }
+    return this.context.get(Common.Console.Console);
+  }
+
+  // TODO(crbug.com/493763857): Remove fallback once all unit tests use TestUniverse.
+  getFrameManager(): FrameManager {
+    if ('has' in this.context && typeof this.context.has === 'function' && !this.context.has(FrameManager)) {
+      return FrameManager.instance();
+    }
+    return this.context.get(FrameManager);
+  }
+
   /* eslint-disable @typescript-eslint/no-explicit-any */
   #modelListeners: Platform.MapUtilities.Multimap<string|symbol|number, {
     modelClass: SDKModelConstructor,

package/front_end/entrypoints/devtools_app/devtools_app.ts

@@ -5,7 +5,6 @@ import '../shell/shell.js';
 import '../../panels/css_overview/css_overview-meta.js';
 import '../../panels/elements/elements-meta.js';
 import '../../panels/browser_debugger/browser_debugger-meta.js';
-import '../../panels/greendev/greendev-meta.js';
 import '../../panels/network/network-meta.js';
 import '../../panels/security/security-meta.js';
 import '../../panels/emulation/emulation-meta.js';