chrome-devtools-frontend 1.0.1512147 → 1.0.1513662

package/front_end/core/sdk/DOMDebuggerModel.ts

@@ -18,9 +18,9 @@ import {type SDKModelObserver, TargetManager} from './TargetManager.js';
 
 export class DOMDebuggerModel extends SDKModel<EventTypes> {
   readonly agent: ProtocolProxyApi.DOMDebuggerApi;
-  readonly #runtimeModelInternal: RuntimeModel;
+  readonly #runtimeModel: RuntimeModel;
   #domModel: DOMModel;
-  #domBreakpointsInternal: DOMBreakpoint[];
+  #domBreakpoints: DOMBreakpoint[];
   readonly #domBreakpointsSetting: Common.Settings.Setting<Array<{
     url: Platform.DevToolsPath.UrlString,
     path: string,
@@ -32,12 +32,12 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
   constructor(target: Target) {
     super(target);
     this.agent = target.domdebuggerAgent();
-    this.#runtimeModelInternal = (target.model(RuntimeModel) as RuntimeModel);
+    this.#runtimeModel = (target.model(RuntimeModel) as RuntimeModel);
     this.#domModel = (target.model(DOMModel) as DOMModel);
     this.#domModel.addEventListener(DOMModelEvents.DocumentUpdated, this.documentUpdated, this);
     this.#domModel.addEventListener(DOMModelEvents.NodeRemoved, this.nodeRemoved, this);
 
-    this.#domBreakpointsInternal = [];
+    this.#domBreakpoints = [];
     this.#domBreakpointsSetting = Common.Settings.Settings.instance().createLocalSetting('dom-breakpoints', []);
     if (this.#domModel.existingDocument()) {
       void this.documentUpdated();
@@ -45,7 +45,7 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
   }
 
   runtimeModel(): RuntimeModel {
-    return this.#runtimeModelInternal;
+    return this.#runtimeModel;
   }
 
   override async suspendModel(): Promise<void> {
@@ -57,7 +57,7 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
   }
 
   async eventListeners(remoteObject: RemoteObject): Promise<EventListener[]> {
-    console.assert(remoteObject.runtimeModel() === this.#runtimeModelInternal);
+    console.assert(remoteObject.runtimeModel() === this.#runtimeModel);
     if (!remoteObject.objectId) {
       return [];
     }
@@ -65,16 +65,16 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
     const listeners = await this.agent.invoke_getEventListeners({objectId: remoteObject.objectId});
     const eventListeners = [];
     for (const payload of listeners.listeners || []) {
-      const location = this.#runtimeModelInternal.debuggerModel().createRawLocationByScriptId(
+      const location = this.#runtimeModel.debuggerModel().createRawLocationByScriptId(
           payload.scriptId, payload.lineNumber, payload.columnNumber);
       if (!location) {
         continue;
       }
       eventListeners.push(new EventListener(
           this, remoteObject, payload.type, payload.useCapture, payload.passive, payload.once,
-          payload.handler ? this.#runtimeModelInternal.createRemoteObject(payload.handler) : null,
-          payload.originalHandler ? this.#runtimeModelInternal.createRemoteObject(payload.originalHandler) : null,
-          location, null));
+          payload.handler ? this.#runtimeModel.createRemoteObject(payload.handler) : null,
+          payload.originalHandler ? this.#runtimeModel.createRemoteObject(payload.originalHandler) : null, location,
+          null));
     }
     return eventListeners;
   }
@@ -84,22 +84,22 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
   }
 
   domBreakpoints(): DOMBreakpoint[] {
-    return this.#domBreakpointsInternal.slice();
+    return this.#domBreakpoints.slice();
   }
 
   hasDOMBreakpoint(node: DOMNode, type: Protocol.DOMDebugger.DOMBreakpointType): boolean {
-    return this.#domBreakpointsInternal.some(breakpoint => (breakpoint.node === node && breakpoint.type === type));
+    return this.#domBreakpoints.some(breakpoint => (breakpoint.node === node && breakpoint.type === type));
   }
 
   setDOMBreakpoint(node: DOMNode, type: Protocol.DOMDebugger.DOMBreakpointType): DOMBreakpoint {
-    for (const breakpoint of this.#domBreakpointsInternal) {
+    for (const breakpoint of this.#domBreakpoints) {
       if (breakpoint.node === node && breakpoint.type === type) {
         this.toggleDOMBreakpoint(breakpoint, true);
         return breakpoint;
       }
     }
     const breakpoint = new DOMBreakpoint(this, node, type, true);
-    this.#domBreakpointsInternal.push(breakpoint);
+    this.#domBreakpoints.push(breakpoint);
     this.enableDOMBreakpoint(breakpoint);
     this.saveDOMBreakpoints();
     this.dispatchEventToListeners(Events.DOM_BREAKPOINT_ADDED, breakpoint);
@@ -143,7 +143,7 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
   }
 
   private nodeHasBreakpoints(node: DOMNode): boolean {
-    for (const breakpoint of this.#domBreakpointsInternal) {
+    for (const breakpoint of this.#domBreakpoints) {
       if (breakpoint.node === node && breakpoint.enabled) {
         return true;
       }
@@ -185,8 +185,8 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
     if (this.suspended) {
       return;
     }
-    const removed = this.#domBreakpointsInternal;
-    this.#domBreakpointsInternal = [];
+    const removed = this.#domBreakpoints;
+    this.#domBreakpoints = [];
     this.dispatchEventToListeners(Events.DOM_BREAKPOINTS_REMOVED, removed);
 
     // this.currentURL() is empty when the page is reloaded because the
@@ -216,14 +216,14 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
       // Before creating a new DOMBreakpoint, we need to ensure there's no
       // existing breakpoint with the same node and breakpoint type, else we would create
       // multiple DOMBreakpoints of the same type and for the same node.
-      for (const existingBreakpoint of this.#domBreakpointsInternal) {
+      for (const existingBreakpoint of this.#domBreakpoints) {
         if (existingBreakpoint.node === node && existingBreakpoint.type === breakpoint.type) {
           return;
         }
       }
 
       const domBreakpoint = new DOMBreakpoint(this, node, breakpoint.type, breakpoint.enabled);
-      this.#domBreakpointsInternal.push(domBreakpoint);
+      this.#domBreakpoints.push(domBreakpoint);
       if (breakpoint.enabled) {
         this.enableDOMBreakpoint(domBreakpoint);
       }
@@ -234,7 +234,7 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
   private removeDOMBreakpoints(filter: (arg0: DOMBreakpoint) => boolean): void {
     const removed = [];
     const left = [];
-    for (const breakpoint of this.#domBreakpointsInternal) {
+    for (const breakpoint of this.#domBreakpoints) {
       if (filter(breakpoint)) {
         removed.push(breakpoint);
         if (breakpoint.enabled) {
@@ -249,7 +249,7 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
     if (!removed.length) {
       return;
     }
-    this.#domBreakpointsInternal = left;
+    this.#domBreakpoints = left;
     this.saveDOMBreakpoints();
     this.dispatchEventToListeners(Events.DOM_BREAKPOINTS_REMOVED, removed);
   }
@@ -268,7 +268,7 @@ export class DOMDebuggerModel extends SDKModel<EventTypes> {
     const breakpoints = this.#domBreakpointsSetting.get().filter((breakpoint: {
                                                                    url: Platform.DevToolsPath.UrlString,
                                                                  }) => breakpoint.url !== currentURL);
-    for (const breakpoint of this.#domBreakpointsInternal) {
+    for (const breakpoint of this.#domBreakpoints) {
       breakpoints.push(
           {url: currentURL, path: breakpoint.node.path(), type: breakpoint.type, enabled: breakpoint.enabled});
     }
@@ -307,76 +307,76 @@ export class DOMBreakpoint {
 }
 
 export class EventListener {
-  readonly #domDebuggerModelInternal: DOMDebuggerModel;
+  readonly #domDebuggerModel: DOMDebuggerModel;
   readonly #eventTarget: RemoteObject;
-  readonly #typeInternal: string;
-  readonly #useCaptureInternal: boolean;
-  readonly #passiveInternal: boolean;
-  readonly #onceInternal: boolean;
-  readonly #handlerInternal: RemoteObject|null;
-  readonly #originalHandlerInternal: RemoteObject|null;
-  readonly #locationInternal: Location;
-  readonly #sourceURLInternal: Platform.DevToolsPath.UrlString;
+  readonly #type: string;
+  readonly #useCapture: boolean;
+  readonly #passive: boolean;
+  readonly #once: boolean;
+  readonly #handler: RemoteObject|null;
+  readonly #originalHandler: RemoteObject|null;
+  readonly #location: Location;
+  readonly #sourceURL: Platform.DevToolsPath.UrlString;
   readonly #customRemoveFunction: RemoteObject|null;
-  #originInternal: string;
+  #origin: string;
 
   constructor(
       domDebuggerModel: DOMDebuggerModel, eventTarget: RemoteObject, type: string, useCapture: boolean,
       passive: boolean, once: boolean, handler: RemoteObject|null, originalHandler: RemoteObject|null,
       location: Location, customRemoveFunction: RemoteObject|null, origin?: string) {
-    this.#domDebuggerModelInternal = domDebuggerModel;
+    this.#domDebuggerModel = domDebuggerModel;
     this.#eventTarget = eventTarget;
-    this.#typeInternal = type;
-    this.#useCaptureInternal = useCapture;
-    this.#passiveInternal = passive;
-    this.#onceInternal = once;
-    this.#handlerInternal = handler;
-    this.#originalHandlerInternal = originalHandler || handler;
-    this.#locationInternal = location;
+    this.#type = type;
+    this.#useCapture = useCapture;
+    this.#passive = passive;
+    this.#once = once;
+    this.#handler = handler;
+    this.#originalHandler = originalHandler || handler;
+    this.#location = location;
     const script = location.script();
-    this.#sourceURLInternal = script ? script.contentURL() : Platform.DevToolsPath.EmptyUrlString;
+    this.#sourceURL = script ? script.contentURL() : Platform.DevToolsPath.EmptyUrlString;
     this.#customRemoveFunction = customRemoveFunction;
-    this.#originInternal = origin || EventListener.Origin.RAW;
+    this.#origin = origin || EventListener.Origin.RAW;
   }
 
   domDebuggerModel(): DOMDebuggerModel {
-    return this.#domDebuggerModelInternal;
+    return this.#domDebuggerModel;
   }
 
   type(): string {
-    return this.#typeInternal;
+    return this.#type;
   }
 
   useCapture(): boolean {
-    return this.#useCaptureInternal;
+    return this.#useCapture;
   }
 
   passive(): boolean {
-    return this.#passiveInternal;
+    return this.#passive;
   }
 
   once(): boolean {
-    return this.#onceInternal;
+    return this.#once;
   }
 
   handler(): RemoteObject|null {
-    return this.#handlerInternal;
+    return this.#handler;
   }
 
   location(): Location {
-    return this.#locationInternal;
+    return this.#location;
   }
 
   sourceURL(): Platform.DevToolsPath.UrlString {
-    return this.#sourceURLInternal;
+    return this.#sourceURL;
   }
 
   originalHandler(): RemoteObject|null {
-    return this.#originalHandlerInternal;
+    return this.#originalHandler;
   }
 
   canRemove(): boolean {
-    return Boolean(this.#customRemoveFunction) || this.#originInternal !== EventListener.Origin.FRAMEWORK_USER;
+    return Boolean(this.#customRemoveFunction) || this.#origin !== EventListener.Origin.FRAMEWORK_USER;
   }
 
   remove(): Promise<void> {
@@ -384,7 +384,7 @@ export class EventListener {
       return Promise.resolve(undefined);
     }
 
-    if (this.#originInternal !== EventListener.Origin.FRAMEWORK_USER) {
+    if (this.#origin !== EventListener.Origin.FRAMEWORK_USER) {
       function removeListener(
           this: {
             removeEventListener: (arg0: string, arg1: () => void, arg2: boolean) => void,
@@ -402,9 +402,9 @@ export class EventListener {
           .callFunction(
               removeListener,
               [
-                RemoteObject.toCallArgument(this.#typeInternal),
-                RemoteObject.toCallArgument(this.#originalHandlerInternal),
-                RemoteObject.toCallArgument(this.#useCaptureInternal),
+                RemoteObject.toCallArgument(this.#type),
+                RemoteObject.toCallArgument(this.#originalHandler),
+                RemoteObject.toCallArgument(this.#useCapture),
               ])
           .then(() => undefined);
     }
@@ -420,10 +420,10 @@ export class EventListener {
           .callFunction(
               callCustomRemove,
               [
-                RemoteObject.toCallArgument(this.#typeInternal),
-                RemoteObject.toCallArgument(this.#originalHandlerInternal),
-                RemoteObject.toCallArgument(this.#useCaptureInternal),
-                RemoteObject.toCallArgument(this.#passiveInternal),
+                RemoteObject.toCallArgument(this.#type),
+                RemoteObject.toCallArgument(this.#originalHandler),
+                RemoteObject.toCallArgument(this.#useCapture),
+                RemoteObject.toCallArgument(this.#passive),
               ])
           .then(() => undefined);
     }
@@ -431,7 +431,7 @@ export class EventListener {
   }
 
   canTogglePassive(): boolean {
-    return this.#originInternal !== EventListener.Origin.FRAMEWORK_USER;
+    return this.#origin !== EventListener.Origin.FRAMEWORK_USER;
   }
 
   togglePassive(): Promise<undefined> {
@@ -439,10 +439,10 @@ export class EventListener {
         .callFunction(
             callTogglePassive,
             [
-              RemoteObject.toCallArgument(this.#typeInternal),
-              RemoteObject.toCallArgument(this.#originalHandlerInternal),
-              RemoteObject.toCallArgument(this.#useCaptureInternal),
-              RemoteObject.toCallArgument(this.#passiveInternal),
+              RemoteObject.toCallArgument(this.#type),
+              RemoteObject.toCallArgument(this.#originalHandler),
+              RemoteObject.toCallArgument(this.#useCapture),
+              RemoteObject.toCallArgument(this.#passive),
             ])
         .then(() => undefined);
 
@@ -463,16 +463,16 @@ export class EventListener {
   }
 
   origin(): string {
-    return this.#originInternal;
+    return this.#origin;
   }
 
   markAsFramework(): void {
-    this.#originInternal = EventListener.Origin.FRAMEWORK;
+    this.#origin = EventListener.Origin.FRAMEWORK;
   }
 
   isScrollBlockingType(): boolean {
-    return this.#typeInternal === 'touchstart' || this.#typeInternal === 'touchmove' ||
-        this.#typeInternal === 'mousewheel' || this.#typeInternal === 'wheel';
+    return this.#type === 'touchstart' || this.#type === 'touchmove' || this.#type === 'mousewheel' ||
+        this.#type === 'wheel';
   }
 }
 
@@ -485,14 +485,14 @@ export namespace EventListener {
 }
 
 export class CSPViolationBreakpoint extends CategorizedBreakpoint {
-  readonly #typeInternal: Protocol.DOMDebugger.CSPViolationType;
+  readonly #type: Protocol.DOMDebugger.CSPViolationType;
   constructor(category: Category, type: Protocol.DOMDebugger.CSPViolationType) {
     super(category, type);
-    this.#typeInternal = type;
+    this.#type = type;
   }
 
   type(): Protocol.DOMDebugger.CSPViolationType {
-    return this.#typeInternal;
+    return this.#type;
   }
 }
 
@@ -530,15 +530,15 @@ let domDebuggerManagerInstance: DOMDebuggerManager;
 
 export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   readonly #xhrBreakpointsSetting: Common.Settings.Setting<Array<{url: string, enabled: boolean}>>;
-  readonly #xhrBreakpointsInternal = new Map<string, boolean>();
+  readonly #xhrBreakpoints = new Map<string, boolean>();
 
   readonly #cspViolationsToBreakOn: CSPViolationBreakpoint[] = [];
-  readonly #eventListenerBreakpointsInternal: DOMEventListenerBreakpoint[] = [];
+  readonly #eventListenerBreakpoints: DOMEventListenerBreakpoint[] = [];
 
   constructor() {
     this.#xhrBreakpointsSetting = Common.Settings.Settings.instance().createLocalSetting('xhr-breakpoints', []);
     for (const breakpoint of this.#xhrBreakpointsSetting.get()) {
-      this.#xhrBreakpointsInternal.set(breakpoint.url, breakpoint.enabled);
+      this.#xhrBreakpoints.set(breakpoint.url, breakpoint.enabled);
     }
 
     this.#cspViolationsToBreakOn.push(new CSPViolationBreakpoint(
@@ -679,8 +679,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
 
   private createEventListenerBreakpoints(category: Category, eventNames: string[], eventTargetNames: string[]): void {
     for (const eventName of eventNames) {
-      this.#eventListenerBreakpointsInternal.push(
-          new DOMEventListenerBreakpoint(eventName, eventTargetNames, category));
+      this.#eventListenerBreakpoints.push(new DOMEventListenerBreakpoint(eventName, eventTargetNames, category));
     }
   }
 
@@ -694,7 +693,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
     }
     targetName = (targetName || '*').toLowerCase();
     let result: DOMEventListenerBreakpoint|null = null;
-    for (const breakpoint of this.#eventListenerBreakpointsInternal) {
+    for (const breakpoint of this.#eventListenerBreakpoints) {
       if (eventName && breakpoint.name === eventName && breakpoint.eventTargetNames.indexOf(targetName) !== -1) {
         result = breakpoint;
       }
@@ -706,7 +705,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   }
 
   eventListenerBreakpoints(): DOMEventListenerBreakpoint[] {
-    return this.#eventListenerBreakpointsInternal.slice();
+    return this.#eventListenerBreakpoints.slice();
   }
 
   updateCSPViolationBreakpoints(): void {
@@ -722,19 +721,19 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   }
 
   xhrBreakpoints(): Map<string, boolean> {
-    return this.#xhrBreakpointsInternal;
+    return this.#xhrBreakpoints;
   }
 
   private saveXHRBreakpoints(): void {
     const breakpoints = [];
-    for (const url of this.#xhrBreakpointsInternal.keys()) {
-      breakpoints.push({url, enabled: this.#xhrBreakpointsInternal.get(url) || false});
+    for (const url of this.#xhrBreakpoints.keys()) {
+      breakpoints.push({url, enabled: this.#xhrBreakpoints.get(url) || false});
     }
     this.#xhrBreakpointsSetting.set(breakpoints);
   }
 
   addXHRBreakpoint(url: string, enabled: boolean): void {
-    this.#xhrBreakpointsInternal.set(url, enabled);
+    this.#xhrBreakpoints.set(url, enabled);
     if (enabled) {
       for (const model of TargetManager.instance().models(DOMDebuggerModel)) {
         void model.agent.invoke_setXHRBreakpoint({url});
@@ -744,8 +743,8 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   }
 
   removeXHRBreakpoint(url: string): void {
-    const enabled = this.#xhrBreakpointsInternal.get(url);
-    this.#xhrBreakpointsInternal.delete(url);
+    const enabled = this.#xhrBreakpoints.get(url);
+    this.#xhrBreakpoints.delete(url);
     if (enabled) {
       for (const model of TargetManager.instance().models(DOMDebuggerModel)) {
         void model.agent.invoke_removeXHRBreakpoint({url});
@@ -755,7 +754,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   }
 
   toggleXHRBreakpoint(url: string, enabled: boolean): void {
-    this.#xhrBreakpointsInternal.set(url, enabled);
+    this.#xhrBreakpoints.set(url, enabled);
     for (const model of TargetManager.instance().models(DOMDebuggerModel)) {
       if (enabled) {
         void model.agent.invoke_setXHRBreakpoint({url});
@@ -767,12 +766,12 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   }
 
   modelAdded(domDebuggerModel: DOMDebuggerModel): void {
-    for (const url of this.#xhrBreakpointsInternal.keys()) {
-      if (this.#xhrBreakpointsInternal.get(url)) {
+    for (const url of this.#xhrBreakpoints.keys()) {
+      if (this.#xhrBreakpoints.get(url)) {
         void domDebuggerModel.agent.invoke_setXHRBreakpoint({url});
       }
     }
-    for (const breakpoint of this.#eventListenerBreakpointsInternal) {
+    for (const breakpoint of this.#eventListenerBreakpoints) {
       if (breakpoint.enabled()) {
         breakpoint.updateOnModel(domDebuggerModel);
       }