chrome-devtools-frontend 1.0.927127 → 1.0.928589

package/front_end/core/sdk/ConsoleModel.ts

@@ -77,25 +77,25 @@ const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 let settingsInstance: ConsoleModel;
 
 export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements Observer {
-  private messagesInternal: ConsoleMessage[];
-  private readonly messageByExceptionId: Map<RuntimeModel, Map<number, ConsoleMessage>>;
-  private warningsInternal: number;
-  private errorsInternal: number;
-  private violationsInternal: number;
-  private pageLoadSequenceNumber: number;
-  private readonly targetListeners: WeakMap<Target, Common.EventTarget.EventDescriptor[]>;
-  private consoleGroupMessageStack: ConsoleMessage[] = [];
+  #messagesInternal: ConsoleMessage[];
+  readonly #messageByExceptionId: Map<RuntimeModel, Map<number, ConsoleMessage>>;
+  #warningsInternal: number;
+  #errorsInternal: number;
+  #violationsInternal: number;
+  #pageLoadSequenceNumber: number;
+  readonly #targetListeners: WeakMap<Target, Common.EventTarget.EventDescriptor[]>;
+  #consoleGroupMessageStack: ConsoleMessage[] = [];
 
   private constructor() {
     super();
 
-    this.messagesInternal = [];
-    this.messageByExceptionId = new Map();
-    this.warningsInternal = 0;
-    this.errorsInternal = 0;
-    this.violationsInternal = 0;
-    this.pageLoadSequenceNumber = 0;
-    this.targetListeners = new WeakMap();
+    this.#messagesInternal = [];
+    this.#messageByExceptionId = new Map();
+    this.#warningsInternal = 0;
+    this.#errorsInternal = 0;
+    this.#violationsInternal = 0;
+    this.#pageLoadSequenceNumber = 0;
+    this.#targetListeners = new WeakMap();
 
     TargetManager.instance().observeTargets(this);
   }
@@ -157,15 +157,15 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
           RuntimeModelEvents.QueryObjectRequested, this.queryObjectRequested.bind(this, runtimeModel)));
     }
 
-    this.targetListeners.set(target, eventListeners);
+    this.#targetListeners.set(target, eventListeners);
   }
 
   targetRemoved(target: Target): void {
     const runtimeModel = target.model(RuntimeModel);
     if (runtimeModel) {
-      this.messageByExceptionId.delete(runtimeModel);
+      this.#messageByExceptionId.delete(runtimeModel);
     }
-    Common.EventTarget.removeEventListeners(this.targetListeners.get(target) || []);
+    Common.EventTarget.removeEventListeners(this.#targetListeners.get(target) || []);
   }
 
   async evaluateCommandInConsole(
@@ -206,20 +206,20 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
   }
 
   addMessage(msg: ConsoleMessage): void {
-    msg.setPageLoadSequenceNumber(this.pageLoadSequenceNumber);
+    msg.setPageLoadSequenceNumber(this.#pageLoadSequenceNumber);
     if (msg.source === FrontendMessageSource.ConsoleAPI &&
         msg.type === Protocol.Runtime.ConsoleAPICalledEventType.Clear) {
       this.clearIfNecessary();
     }
 
-    this.messagesInternal.push(msg);
+    this.#messagesInternal.push(msg);
     const runtimeModel = msg.runtimeModel();
     const exceptionId = msg.getExceptionId();
     if (exceptionId && runtimeModel) {
-      let modelMap = this.messageByExceptionId.get(runtimeModel);
+      let modelMap = this.#messageByExceptionId.get(runtimeModel);
       if (!modelMap) {
         modelMap = new Map();
-        this.messageByExceptionId.set(runtimeModel, modelMap);
+        this.#messageByExceptionId.set(runtimeModel, modelMap);
       }
       modelMap.set(exceptionId, msg);
     }
@@ -240,12 +240,12 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
 
   private exceptionRevoked(runtimeModel: RuntimeModel, event: Common.EventTarget.EventTargetEvent<number>): void {
     const exceptionId = event.data;
-    const modelMap = this.messageByExceptionId.get(runtimeModel);
+    const modelMap = this.#messageByExceptionId.get(runtimeModel);
     const exceptionMessage = modelMap ? modelMap.get(exceptionId) : null;
     if (!exceptionMessage) {
       return;
     }
-    this.errorsInternal--;
+    this.#errorsInternal--;
     exceptionMessage.level = Protocol.Log.LogEntryLevel.Verbose;
     this.dispatchEventToListeners(Events.MessageUpdated, exceptionMessage);
   }
@@ -276,7 +276,7 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
       message = call.args[0].description;
     }
     const callFrame = call.stackTrace && call.stackTrace.callFrames.length ? call.stackTrace.callFrames[0] : null;
-    const groupParent = this.consoleGroupMessageStack[this.consoleGroupMessageStack.length - 1];
+    const groupParent = this.#consoleGroupMessageStack[this.#consoleGroupMessageStack.length - 1];
     const details = {
       type: call.type,
       url: callFrame?.url,
@@ -293,10 +293,10 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     const consoleMessage =
         new ConsoleMessage(runtimeModel, FrontendMessageSource.ConsoleAPI, level, (message as string), details);
     if (call.type === Protocol.Runtime.ConsoleAPICalledEventType.StartGroup) {
-      this.consoleGroupMessageStack.push(consoleMessage);
+      this.#consoleGroupMessageStack.push(consoleMessage);
     }
     if (call.type === Protocol.Runtime.ConsoleAPICalledEventType.EndGroup) {
-      this.consoleGroupMessageStack.pop();
+      this.#consoleGroupMessageStack.pop();
     }
     if (groupParent && call.type !== Protocol.Runtime.ConsoleAPICalledEventType.EndGroup) {
       groupParent.groupChildren?.push(consoleMessage);
@@ -321,7 +321,7 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     if (!Common.Settings.Settings.instance().moduleSetting('preserveConsoleLog').get()) {
       this.clear();
     }
-    ++this.pageLoadSequenceNumber;
+    ++this.#pageLoadSequenceNumber;
   }
 
   private mainFrameNavigated(event: Common.EventTarget.EventTargetEvent<ResourceTreeFrame>): void {
@@ -363,21 +363,21 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
 
   private incrementErrorWarningCount(msg: ConsoleMessage): void {
     if (msg.source === Protocol.Log.LogEntrySource.Violation) {
-      this.violationsInternal++;
+      this.#violationsInternal++;
       return;
     }
     switch (msg.level) {
       case Protocol.Log.LogEntryLevel.Warning:
-        this.warningsInternal++;
+        this.#warningsInternal++;
         break;
       case Protocol.Log.LogEntryLevel.Error:
-        this.errorsInternal++;
+        this.#errorsInternal++;
         break;
     }
   }
 
   messages(): ConsoleMessage[] {
-    return this.messagesInternal;
+    return this.#messagesInternal;
   }
 
   requestClearMessages(): void {
@@ -391,25 +391,25 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
   }
 
   private clear(): void {
-    this.messagesInternal = [];
-    this.consoleGroupMessageStack = [];
-    this.messageByExceptionId.clear();
-    this.errorsInternal = 0;
-    this.warningsInternal = 0;
-    this.violationsInternal = 0;
+    this.#messagesInternal = [];
+    this.#consoleGroupMessageStack = [];
+    this.#messageByExceptionId.clear();
+    this.#errorsInternal = 0;
+    this.#warningsInternal = 0;
+    this.#violationsInternal = 0;
     this.dispatchEventToListeners(Events.ConsoleCleared);
   }
 
   errors(): number {
-    return this.errorsInternal;
+    return this.#errorsInternal;
   }
 
   warnings(): number {
-    return this.warningsInternal;
+    return this.#warningsInternal;
   }
 
   violations(): number {
-    return this.violationsInternal;
+    return this.#violationsInternal;
   }
 
   async saveToTempVariable(currentExecutionContext: ExecutionContext|null, remoteObject: RemoteObject|null):
@@ -501,7 +501,7 @@ function extractExceptionMetaData(metaData: any|undefined): AffectedResources|un
 }
 
 function areAffectedResourcesEquivalent(a?: AffectedResources, b?: AffectedResources): boolean {
-  // Not considering issueId, as that would prevent de-duplication of console messages.
+  // Not considering issueId, as that would prevent de-duplication of console #messages.
   return a?.requestId === b?.requestId;
 }
 
@@ -524,7 +524,7 @@ export interface ConsoleMessageDetails {
 }
 
 export class ConsoleMessage {
-  private readonly runtimeModelInternal: RuntimeModel|null;
+  readonly #runtimeModelInternal: RuntimeModel|null;
   source: MessageSource;
   level: Protocol.Log.LogEntryLevel|null;
   messageText: string;
@@ -535,14 +535,14 @@ export class ConsoleMessage {
   parameters: (string|RemoteObject|Protocol.Runtime.RemoteObject)[]|undefined;
   stackTrace: Protocol.Runtime.StackTrace|undefined;
   timestamp: number;
-  private executionContextId: number;
+  #executionContextId: number;
   scriptId?: Protocol.Runtime.ScriptId;
   workerId?: string;
   context?: string;
-  private originatingConsoleMessage: ConsoleMessage|null = null;
-  private pageLoadSequenceNumber?: number = undefined;
-  private exceptionId?: number = undefined;
-  private affectedResources?: AffectedResources;
+  #originatingConsoleMessage: ConsoleMessage|null = null;
+  #pageLoadSequenceNumber?: number = undefined;
+  #exceptionId?: number = undefined;
+  #affectedResources?: AffectedResources;
   groupParent?: ConsoleMessage;
   groupChildren?: Array<ConsoleMessage>;
   category?: Protocol.Log.LogEntryCategory;
@@ -550,7 +550,7 @@ export class ConsoleMessage {
   constructor(
       runtimeModel: RuntimeModel|null, source: MessageSource, level: Protocol.Log.LogEntryLevel|null,
       messageText: string, details?: ConsoleMessageDetails) {
-    this.runtimeModelInternal = runtimeModel;
+    this.#runtimeModelInternal = runtimeModel;
     this.source = source;
     this.level = (level as Protocol.Log.LogEntryLevel | null);
     this.messageText = messageText;
@@ -561,19 +561,19 @@ export class ConsoleMessage {
     this.parameters = details?.parameters;
     this.stackTrace = details?.stackTrace;
     this.timestamp = details?.timestamp || Date.now();
-    this.executionContextId = details?.executionContextId || 0;
+    this.#executionContextId = details?.executionContextId || 0;
     this.scriptId = details?.scriptId;
     this.workerId = details?.workerId;
-    this.affectedResources = details?.affectedResources;
+    this.#affectedResources = details?.affectedResources;
     this.groupParent = details?.groupParent;
     this.groupChildren = details?.groupChildren;
     this.category = details?.category;
 
-    if (!this.executionContextId && this.runtimeModelInternal) {
+    if (!this.#executionContextId && this.#runtimeModelInternal) {
       if (this.scriptId) {
-        this.executionContextId = this.runtimeModelInternal.executionContextIdForScriptId(this.scriptId);
+        this.#executionContextId = this.#runtimeModelInternal.executionContextIdForScriptId(this.scriptId);
       } else if (this.stackTrace) {
-        this.executionContextId = this.runtimeModelInternal.executionContextForStackTrace(this.stackTrace);
+        this.#executionContextId = this.#runtimeModelInternal.executionContextForStackTrace(this.stackTrace);
       }
     }
 
@@ -584,11 +584,11 @@ export class ConsoleMessage {
   }
 
   getAffectedResources(): AffectedResources|undefined {
-    return this.affectedResources;
+    return this.#affectedResources;
   }
 
   setPageLoadSequenceNumber(pageLoadSequenceNumber: number): void {
-    this.pageLoadSequenceNumber = pageLoadSequenceNumber;
+    this.#pageLoadSequenceNumber = pageLoadSequenceNumber;
   }
 
   static fromException(
@@ -615,36 +615,36 @@ export class ConsoleMessage {
   }
 
   runtimeModel(): RuntimeModel|null {
-    return this.runtimeModelInternal;
+    return this.#runtimeModelInternal;
   }
 
   target(): Target|null {
-    return this.runtimeModelInternal ? this.runtimeModelInternal.target() : null;
+    return this.#runtimeModelInternal ? this.#runtimeModelInternal.target() : null;
   }
 
   setOriginatingMessage(originatingMessage: ConsoleMessage): void {
-    this.originatingConsoleMessage = originatingMessage;
-    this.executionContextId = originatingMessage.executionContextId;
+    this.#originatingConsoleMessage = originatingMessage;
+    this.#executionContextId = originatingMessage.#executionContextId;
   }
 
   originatingMessage(): ConsoleMessage|null {
-    return this.originatingConsoleMessage;
+    return this.#originatingConsoleMessage;
   }
 
   setExecutionContextId(executionContextId: number): void {
-    this.executionContextId = executionContextId;
+    this.#executionContextId = executionContextId;
   }
 
   getExecutionContextId(): number {
-    return this.executionContextId;
+    return this.#executionContextId;
   }
 
   getExceptionId(): number|undefined {
-    return this.exceptionId;
+    return this.#exceptionId;
   }
 
   setExceptionId(exceptionId: number): void {
-    this.exceptionId = exceptionId;
+    this.#exceptionId = exceptionId;
   }
 
   isGroupMessage(): boolean {
@@ -671,7 +671,7 @@ export class ConsoleMessage {
   }
 
   groupCategoryKey(): string {
-    return [this.source, this.level, this.type, this.pageLoadSequenceNumber].join(':');
+    return [this.source, this.level, this.type, this.#pageLoadSequenceNumber].join(':');
   }
 
   isEqual(msg: ConsoleMessage|null): boolean {
@@ -714,8 +714,8 @@ export class ConsoleMessage {
     return (this.runtimeModel() === msg.runtimeModel()) && (this.source === msg.source) && (this.type === msg.type) &&
         (this.level === msg.level) && (this.line === msg.line) && (this.url === msg.url) &&
         (bothAreWatchExpressions || this.scriptId === msg.scriptId) && (this.messageText === msg.messageText) &&
-        (this.executionContextId === msg.executionContextId) &&
-        areAffectedResourcesEquivalent(this.affectedResources, msg.affectedResources);
+        (this.#executionContextId === msg.#executionContextId) &&
+        areAffectedResourcesEquivalent(this.#affectedResources, msg.#affectedResources);
   }
 
   private isEqualStackTraces(

package/front_end/core/sdk/Cookie.ts

@@ -5,23 +5,23 @@
 import type * as Protocol from '../../generated/protocol.js';
 
 export class Cookie {
-  private readonly nameInternal: string;
-  private readonly valueInternal: string;
-  private readonly typeInternal: Type|null|undefined;
-  private attributes: {
+  readonly #nameInternal: string;
+  readonly #valueInternal: string;
+  readonly #typeInternal: Type|null|undefined;
+  #attributes: {
     [x: string]: string|number|boolean|undefined,
   };
-  private sizeInternal: number;
-  private priorityInternal: Protocol.Network.CookiePriority;
-  private cookieLine: string|null;
+  #sizeInternal: number;
+  #priorityInternal: Protocol.Network.CookiePriority;
+  #cookieLine: string|null;
   constructor(name: string, value: string, type?: Type|null, priority?: Protocol.Network.CookiePriority) {
-    this.nameInternal = name;
-    this.valueInternal = value;
-    this.typeInternal = type;
-    this.attributes = {};
-    this.sizeInternal = 0;
-    this.priorityInternal = (priority || 'Medium' as Protocol.Network.CookiePriority);
-    this.cookieLine = null;
+    this.#nameInternal = name;
+    this.#valueInternal = value;
+    this.#typeInternal = type;
+    this.#attributes = {};
+    this.#sizeInternal = 0;
+    this.#priorityInternal = (priority || 'Medium' as Protocol.Network.CookiePriority);
+    this.#cookieLine = null;
   }
 
   static fromProtocolCookie(protocolCookie: Protocol.Network.Cookie): Cookie {
@@ -58,71 +58,71 @@ export class Cookie {
   }
 
   name(): string {
-    return this.nameInternal;
+    return this.#nameInternal;
   }
 
   value(): string {
-    return this.valueInternal;
+    return this.#valueInternal;
   }
 
   type(): Type|null|undefined {
-    return this.typeInternal;
+    return this.#typeInternal;
   }
 
   httpOnly(): boolean {
-    return 'httponly' in this.attributes;
+    return 'httponly' in this.#attributes;
   }
 
   secure(): boolean {
-    return 'secure' in this.attributes;
+    return 'secure' in this.#attributes;
   }
 
   sameSite(): Protocol.Network.CookieSameSite {
-    // TODO(allada) This should not rely on attributes and instead store them individually.
-    // when attributes get added via addAttribute() they are lowercased, hence the lowercasing of samesite here
-    return this.attributes['samesite'] as Protocol.Network.CookieSameSite;
+    // TODO(allada) This should not rely on #attributes and instead store them individually.
+    // when #attributes get added via addAttribute() they are lowercased, hence the lowercasing of samesite here
+    return this.#attributes['samesite'] as Protocol.Network.CookieSameSite;
   }
 
   sameParty(): boolean {
-    return 'sameparty' in this.attributes;
+    return 'sameparty' in this.#attributes;
   }
 
   priority(): Protocol.Network.CookiePriority {
-    return this.priorityInternal;
+    return this.#priorityInternal;
   }
 
   session(): boolean {
     // RFC 2965 suggests using Discard attribute to mark session cookies, but this does not seem to be widely used.
     // Check for absence of explicitly max-age or expiry date instead.
-    return !('expires' in this.attributes || 'max-age' in this.attributes);
+    return !('expires' in this.#attributes || 'max-age' in this.#attributes);
   }
 
   path(): string {
-    return this.attributes['path'] as string;
+    return this.#attributes['path'] as string;
   }
 
   domain(): string {
-    return this.attributes['domain'] as string;
+    return this.#attributes['domain'] as string;
   }
 
   expires(): number {
-    return this.attributes['expires'] as number;
+    return this.#attributes['expires'] as number;
   }
 
   maxAge(): number {
-    return this.attributes['max-age'] as number;
+    return this.#attributes['max-age'] as number;
   }
 
   sourcePort(): number {
-    return this.attributes['sourceport'] as number;
+    return this.#attributes['sourceport'] as number;
   }
 
   sourceScheme(): Protocol.Network.CookieSourceScheme {
-    return this.attributes['sourcescheme'] as Protocol.Network.CookieSourceScheme;
+    return this.#attributes['sourcescheme'] as Protocol.Network.CookieSourceScheme;
   }
 
   size(): number {
-    return this.sizeInternal;
+    return this.#sizeInternal;
   }
 
   /**
@@ -144,7 +144,7 @@ export class Cookie {
   }
 
   setSize(size: number): void {
-    this.sizeInternal = size;
+    this.#sizeInternal = size;
   }
 
   expiresDate(requestDate: Date): Date|null {
@@ -164,19 +164,19 @@ export class Cookie {
     const normalizedKey = key.toLowerCase();
     switch (normalizedKey) {
       case 'priority':
-        this.priorityInternal = (value as Protocol.Network.CookiePriority);
+        this.#priorityInternal = (value as Protocol.Network.CookiePriority);
         break;
       default:
-        this.attributes[normalizedKey] = value;
+        this.#attributes[normalizedKey] = value;
     }
   }
 
   setCookieLine(cookieLine: string): void {
-    this.cookieLine = cookieLine;
+    this.#cookieLine = cookieLine;
   }
 
   getCookieLine(): string|null {
-    return this.cookieLine;
+    return this.#cookieLine;
   }
 
   matchesSecurityOrigin(securityOrigin: string): boolean {
@@ -248,26 +248,26 @@ export enum Attributes {
 }
 
 /**
- * A `CookieReference` uniquely identifies a cookie by the triple (name,domain,path). Additionally, a context may be
+ * A `CookieReference` uniquely identifies a cookie by the triple (#name,domain,#path). Additionally, a context may be
  * included to make it clear which site under Application>Cookies should be opened when revealing a `CookieReference`.
  */
 export class CookieReference {
-  private readonly name: string;
-  private readonly domainInternal: string;
-  private readonly path: string;
-  private readonly contextUrlInternal: string|undefined;
+  readonly #name: string;
+  readonly #domainInternal: string;
+  readonly #path: string;
+  readonly #contextUrlInternal: string|undefined;
   constructor(name: string, domain: string, path: string, contextUrl: string|undefined) {
-    this.name = name;
-    this.domainInternal = domain;
-    this.path = path;
-    this.contextUrlInternal = contextUrl;
+    this.#name = name;
+    this.#domainInternal = domain;
+    this.#path = path;
+    this.#contextUrlInternal = contextUrl;
   }
 
   domain(): string {
-    return this.domainInternal;
+    return this.#domainInternal;
   }
 
   contextUrl(): string|undefined {
-    return this.contextUrlInternal;
+    return this.#contextUrlInternal;
   }
 }

package/front_end/core/sdk/CookieModel.ts

@@ -15,31 +15,31 @@ import {Capability} from './Target.js';
 import {SDKModel} from './SDKModel.js';
 
 export class CookieModel extends SDKModel<void> {
-  private readonly blockedCookies: Map<string, Cookie>;
-  private readonly cookieToBlockedReasons: Map<Cookie, BlockedReason[]>;
+  readonly #blockedCookies: Map<string, Cookie>;
+  readonly #cookieToBlockedReasons: Map<Cookie, BlockedReason[]>;
   constructor(target: Target) {
     super(target);
 
-    this.blockedCookies = new Map();
-    this.cookieToBlockedReasons = new Map();
+    this.#blockedCookies = new Map();
+    this.#cookieToBlockedReasons = new Map();
   }
 
   addBlockedCookie(cookie: Cookie, blockedReasons: BlockedReason[]|null): void {
     const key = cookie.key();
-    const previousCookie = this.blockedCookies.get(key);
-    this.blockedCookies.set(key, cookie);
+    const previousCookie = this.#blockedCookies.get(key);
+    this.#blockedCookies.set(key, cookie);
     if (blockedReasons) {
-      this.cookieToBlockedReasons.set(cookie, blockedReasons);
+      this.#cookieToBlockedReasons.set(cookie, blockedReasons);
     } else {
-      this.cookieToBlockedReasons.delete(cookie);
+      this.#cookieToBlockedReasons.delete(cookie);
     }
     if (previousCookie) {
-      this.cookieToBlockedReasons.delete(previousCookie);
+      this.#cookieToBlockedReasons.delete(previousCookie);
     }
   }
 
   getCookieToBlockedReasonsMap(): ReadonlyMap<Cookie, BlockedReason[]> {
-    return this.cookieToBlockedReasons;
+    return this.#cookieToBlockedReasons;
   }
 
   async getCookies(urls: string[]): Promise<Cookie[]> {
@@ -48,7 +48,7 @@ export class CookieModel extends SDKModel<void> {
       return [];
     }
     const normalCookies = response.cookies.map(Cookie.fromProtocolCookie);
-    return normalCookies.concat(Array.from(this.blockedCookies.values()));
+    return normalCookies.concat(Array.from(this.#blockedCookies.values()));
   }
 
   async deleteCookie(cookie: Cookie): Promise<void> {
@@ -129,8 +129,8 @@ export class CookieModel extends SDKModel<void> {
 
   async deleteCookies(cookies: Cookie[]): Promise<void> {
     const networkAgent = this.target().networkAgent();
-    this.blockedCookies.clear();
-    this.cookieToBlockedReasons.clear();
+    this.#blockedCookies.clear();
+    this.#cookieToBlockedReasons.clear();
     await Promise.all(cookies.map(
         cookie => networkAgent.invoke_deleteCookies(
             {name: cookie.name(), url: undefined, domain: cookie.domain(), path: cookie.path()})));