chrome-devtools-frontend 1.0.928589 → 1.0.929998

package/front_end/core/common/Progress.ts

@@ -48,19 +48,19 @@ export class Progress {
 
 export class CompositeProgress {
   readonly parent: Progress;
-  private readonly children: SubProgress[];
-  private childrenDone: number;
+  readonly #children: SubProgress[];
+  #childrenDone: number;
 
   constructor(parent: Progress) {
     this.parent = parent;
-    this.children = [];
-    this.childrenDone = 0;
+    this.#children = [];
+    this.#childrenDone = 0;
     this.parent.setTotalWork(1);
     this.parent.setWorked(0);
   }
 
   childDone(): void {
-    if (++this.childrenDone !== this.children.length) {
+    if (++this.#childrenDone !== this.#children.length) {
       return;
     }
     this.parent.done();
@@ -68,7 +68,7 @@ export class CompositeProgress {
 
   createSubProgress(weight?: number): SubProgress {
     const child = new SubProgress(this, weight);
-    this.children.push(child);
+    this.#children.push(child);
     return child;
   }
 
@@ -76,8 +76,8 @@ export class CompositeProgress {
     let totalWeights = 0;
     let done = 0;
 
-    for (let i = 0; i < this.children.length; ++i) {
-      const child = this.children[i];
+    for (let i = 0; i < this.#children.length; ++i) {
+      const child = this.#children[i];
       if (child.getTotalWork()) {
         done += child.getWeight() * child.getWorked() / child.getTotalWork();
       }
@@ -88,103 +88,103 @@ export class CompositeProgress {
 }
 
 export class SubProgress implements Progress {
-  private readonly composite: CompositeProgress;
-  private weight: number;
-  private worked: number;
-  private totalWork: number;
+  readonly #composite: CompositeProgress;
+  #weight: number;
+  #worked: number;
+  #totalWork: number;
   constructor(composite: CompositeProgress, weight?: number) {
-    this.composite = composite;
-    this.weight = weight || 1;
-    this.worked = 0;
+    this.#composite = composite;
+    this.#weight = weight || 1;
+    this.#worked = 0;
 
-    this.totalWork = 0;
+    this.#totalWork = 0;
   }
 
   isCanceled(): boolean {
-    return this.composite.parent.isCanceled();
+    return this.#composite.parent.isCanceled();
   }
 
   setTitle(title: string): void {
-    this.composite.parent.setTitle(title);
+    this.#composite.parent.setTitle(title);
   }
 
   done(): void {
-    this.setWorked(this.totalWork);
-    this.composite.childDone();
+    this.setWorked(this.#totalWork);
+    this.#composite.childDone();
   }
 
   setTotalWork(totalWork: number): void {
-    this.totalWork = totalWork;
-    this.composite.update();
+    this.#totalWork = totalWork;
+    this.#composite.update();
   }
 
   setWorked(worked: number, title?: string): void {
-    this.worked = worked;
+    this.#worked = worked;
     if (typeof title !== 'undefined') {
       this.setTitle(title);
     }
-    this.composite.update();
+    this.#composite.update();
   }
 
   incrementWorked(worked?: number): void {
-    this.setWorked(this.worked + (worked || 1));
+    this.setWorked(this.#worked + (worked || 1));
   }
 
   getWeight(): number {
-    return this.weight;
+    return this.#weight;
   }
 
   getWorked(): number {
-    return this.worked;
+    return this.#worked;
   }
 
   getTotalWork(): number {
-    return this.totalWork;
+    return this.#totalWork;
   }
 }
 
 export class ProgressProxy implements Progress {
-  private readonly delegate: Progress|null|undefined;
-  private readonly doneCallback: (() => void)|undefined;
+  readonly #delegate: Progress|null|undefined;
+  readonly #doneCallback: (() => void)|undefined;
   constructor(delegate?: Progress|null, doneCallback?: (() => void)) {
-    this.delegate = delegate;
-    this.doneCallback = doneCallback;
+    this.#delegate = delegate;
+    this.#doneCallback = doneCallback;
   }
 
   isCanceled(): boolean {
-    return this.delegate ? this.delegate.isCanceled() : false;
+    return this.#delegate ? this.#delegate.isCanceled() : false;
   }
 
   setTitle(title: string): void {
-    if (this.delegate) {
-      this.delegate.setTitle(title);
+    if (this.#delegate) {
+      this.#delegate.setTitle(title);
     }
   }
 
   done(): void {
-    if (this.delegate) {
-      this.delegate.done();
+    if (this.#delegate) {
+      this.#delegate.done();
     }
-    if (this.doneCallback) {
-      this.doneCallback();
+    if (this.#doneCallback) {
+      this.#doneCallback();
     }
   }
 
   setTotalWork(totalWork: number): void {
-    if (this.delegate) {
-      this.delegate.setTotalWork(totalWork);
+    if (this.#delegate) {
+      this.#delegate.setTotalWork(totalWork);
     }
   }
 
   setWorked(worked: number, title?: string): void {
-    if (this.delegate) {
-      this.delegate.setWorked(worked, title);
+    if (this.#delegate) {
+      this.#delegate.setWorked(worked, title);
     }
   }
 
   incrementWorked(worked?: number): void {
-    if (this.delegate) {
-      this.delegate.incrementWorked(worked);
+    if (this.#delegate) {
+      this.#delegate.incrementWorked(worked);
     }
   }
 }

package/front_end/core/common/ResolverBase.ts

@@ -16,7 +16,7 @@ interface PromiseInfo<T> {
   * promises by using the `clear` method on this class.
   */
 export abstract class ResolverBase<Id, T> {
-  private unresolvedIds: Map<Id, PromiseInfo<T>> = new Map();
+  #unresolvedIds: Map<Id, PromiseInfo<T>> = new Map();
 
   protected abstract getForId(id: Id): T|null;
   protected abstract startListening(): void;
@@ -57,14 +57,14 @@ export abstract class ResolverBase<Id, T> {
    */
   clear(): void {
     this.stopListening();
-    for (const [id, {reject}] of this.unresolvedIds.entries()) {
+    for (const [id, {reject}] of this.#unresolvedIds.entries()) {
       reject(new Error(`Object with ${id} never resolved.`));
     }
-    this.unresolvedIds.clear();
+    this.#unresolvedIds.clear();
   }
 
   private getOrCreatePromise(id: Id): Promise<T> {
-    const promiseInfo = this.unresolvedIds.get(id);
+    const promiseInfo = this.#unresolvedIds.get(id);
     if (promiseInfo) {
       return promiseInfo.promise;
     }
@@ -74,15 +74,15 @@ export abstract class ResolverBase<Id, T> {
       resolve = res;
       reject = rej;
     });
-    this.unresolvedIds.set(id, {promise, resolve, reject});
+    this.#unresolvedIds.set(id, {promise, resolve, reject});
     this.startListening();
     return promise;
   }
 
   protected onResolve(id: Id, t: T): void {
-    const promiseInfo = this.unresolvedIds.get(id);
-    this.unresolvedIds.delete(id);
-    if (this.unresolvedIds.size === 0) {
+    const promiseInfo = this.#unresolvedIds.get(id);
+    this.#unresolvedIds.delete(id);
+    if (this.#unresolvedIds.size === 0) {
       this.stopListening();
     }
     promiseInfo?.resolve(t);

package/front_end/core/common/ResourceType.ts

@@ -170,17 +170,17 @@ const str_ = i18n.i18n.registerUIStrings('core/common/ResourceType.ts', UIString
 const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
 
 export class ResourceType {
-  private readonly nameInternal: string;
-  private readonly titleInternal: () => Platform.UIString.LocalizedString;
-  private readonly categoryInternal: ResourceCategory;
-  private readonly isTextTypeInternal: boolean;
+  readonly #nameInternal: string;
+  readonly #titleInternal: () => Platform.UIString.LocalizedString;
+  readonly #categoryInternal: ResourceCategory;
+  readonly #isTextTypeInternal: boolean;
 
   constructor(
       name: string, title: () => Platform.UIString.LocalizedString, category: ResourceCategory, isTextType: boolean) {
-    this.nameInternal = name;
-    this.titleInternal = title;
-    this.categoryInternal = category;
-    this.isTextTypeInternal = isTextType;
+    this.#nameInternal = name;
+    this.#titleInternal = title;
+    this.#categoryInternal = category;
+    this.#isTextTypeInternal = isTextType;
   }
 
   static fromMimeType(mimeType: string|null): ResourceType {
@@ -258,23 +258,23 @@ export class ResourceType {
   }
 
   name(): string {
-    return this.nameInternal;
+    return this.#nameInternal;
   }
 
   title(): string {
-    return this.titleInternal();
+    return this.#titleInternal();
   }
 
   category(): ResourceCategory {
-    return this.categoryInternal;
+    return this.#categoryInternal;
   }
 
   isTextType(): boolean {
-    return this.isTextTypeInternal;
+    return this.#isTextTypeInternal;
   }
 
   isScript(): boolean {
-    return this.nameInternal === 'script' || this.nameInternal === 'sm-script';
+    return this.#nameInternal === 'script' || this.#nameInternal === 'sm-script';
   }
 
   hasScripts(): boolean {
@@ -282,11 +282,11 @@ export class ResourceType {
   }
 
   isStyleSheet(): boolean {
-    return this.nameInternal === 'stylesheet' || this.nameInternal === 'sm-stylesheet';
+    return this.#nameInternal === 'stylesheet' || this.#nameInternal === 'sm-stylesheet';
   }
 
   isDocument(): boolean {
-    return this.nameInternal === 'document';
+    return this.#nameInternal === 'document';
   }
 
   isDocumentOrScriptOrStyleSheet(): boolean {
@@ -294,23 +294,23 @@ export class ResourceType {
   }
 
   isFont(): boolean {
-    return this.nameInternal === 'font';
+    return this.#nameInternal === 'font';
   }
 
   isImage(): boolean {
-    return this.nameInternal === 'image';
+    return this.#nameInternal === 'image';
   }
 
   isFromSourceMap(): boolean {
-    return this.nameInternal.startsWith('sm-');
+    return this.#nameInternal.startsWith('sm-');
   }
 
   isWebbundle(): boolean {
-    return this.nameInternal === 'webbundle';
+    return this.#nameInternal === 'webbundle';
   }
 
   toString(): string {
-    return this.nameInternal;
+    return this.#nameInternal;
   }
 
   canonicalMimeType(): string {

package/front_end/core/common/SegmentedRange.ts

@@ -24,51 +24,52 @@ export class Segment<T> {
 }
 
 export class SegmentedRange<T> {
-  private segmentsInternal: Segment<T>[];
-  private readonly mergeCallback: ((arg0: Segment<T>, arg1: Segment<T>) => Segment<T>| null)|undefined;
+  #segmentsInternal: Segment<T>[];
+  readonly #mergeCallback: ((arg0: Segment<T>, arg1: Segment<T>) => Segment<T>| null)|undefined;
 
   constructor(mergeCallback?: ((arg0: Segment<T>, arg1: Segment<T>) => Segment<T>| null)) {
-    this.segmentsInternal = [];
-    this.mergeCallback = mergeCallback;
+    this.#segmentsInternal = [];
+    this.#mergeCallback = mergeCallback;
   }
 
   append(newSegment: Segment<T>): void {
     // 1. Find the proper insertion point for new segment
-    let startIndex = Platform.ArrayUtilities.lowerBound(this.segmentsInternal, newSegment, (a, b) => a.begin - b.begin);
+    let startIndex =
+        Platform.ArrayUtilities.lowerBound(this.#segmentsInternal, newSegment, (a, b) => a.begin - b.begin);
     let endIndex = startIndex;
     let merged: (Segment<T>|null)|null = null;
     if (startIndex > 0) {
       // 2. Try mering the preceding segment
-      const precedingSegment = this.segmentsInternal[startIndex - 1];
+      const precedingSegment = this.#segmentsInternal[startIndex - 1];
       merged = this.tryMerge(precedingSegment, newSegment);
       if (merged) {
         --startIndex;
         newSegment = merged;
-      } else if (this.segmentsInternal[startIndex - 1].end >= newSegment.begin) {
+      } else if (this.#segmentsInternal[startIndex - 1].end >= newSegment.begin) {
         // 2a. If merge failed and segments overlap, adjust preceding segment.
         // If an old segment entirely contains new one, split it in two.
         if (newSegment.end < precedingSegment.end) {
-          this.segmentsInternal.splice(
+          this.#segmentsInternal.splice(
               startIndex, 0, new Segment<T>(newSegment.end, precedingSegment.end, precedingSegment.data));
         }
         precedingSegment.end = newSegment.begin;
       }
     }
     // 3. Consume all segments that are entirely covered by the new one.
-    while (endIndex < this.segmentsInternal.length && this.segmentsInternal[endIndex].end <= newSegment.end) {
+    while (endIndex < this.#segmentsInternal.length && this.#segmentsInternal[endIndex].end <= newSegment.end) {
       ++endIndex;
     }
     // 4. Merge or adjust the succeeding segment if it overlaps.
-    if (endIndex < this.segmentsInternal.length) {
-      merged = this.tryMerge(newSegment, this.segmentsInternal[endIndex]);
+    if (endIndex < this.#segmentsInternal.length) {
+      merged = this.tryMerge(newSegment, this.#segmentsInternal[endIndex]);
       if (merged) {
         endIndex++;
         newSegment = merged;
-      } else if (newSegment.intersects(this.segmentsInternal[endIndex])) {
-        this.segmentsInternal[endIndex].begin = newSegment.end;
+      } else if (newSegment.intersects(this.#segmentsInternal[endIndex])) {
+        this.#segmentsInternal[endIndex].begin = newSegment.end;
       }
     }
-    this.segmentsInternal.splice(startIndex, endIndex - startIndex, newSegment);
+    this.#segmentsInternal.splice(startIndex, endIndex - startIndex, newSegment);
   }
 
   appendRange(that: SegmentedRange<T>): void {
@@ -76,11 +77,11 @@ export class SegmentedRange<T> {
   }
 
   segments(): Segment<T>[] {
-    return this.segmentsInternal;
+    return this.#segmentsInternal;
   }
 
   private tryMerge(first: Segment<T>, second: Segment<T>): Segment<T>|null {
-    const merged = this.mergeCallback && this.mergeCallback(first, second);
+    const merged = this.#mergeCallback && this.#mergeCallback(first, second);
     if (!merged) {
       return null;
     }