chrome-devtools-frontend 1.0.1006344 → 1.0.1007778

package/front_end/models/extensions/RecorderExtensionEndpoint.ts

@@ -0,0 +1,43 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import {PrivateAPI} from './ExtensionAPI.js';
+import {ExtensionEndpoint} from './ExtensionEndpoint.js';
+import {RecorderPluginManager} from './RecorderPluginManager.js';
+
+export class RecorderExtensionEndpoint extends ExtensionEndpoint {
+  private readonly name: string;
+
+  constructor(name: string, port: MessagePort) {
+    super(port);
+    this.name = name;
+  }
+
+  getName(): string {
+    return this.name;
+  }
+
+  protected handleEvent({event}: {event: string}): void {
+    switch (event) {
+      case PrivateAPI.RecorderExtensionPluginEvents.UnregisteredRecorderExtensionPlugin: {
+        this.disconnect();
+        RecorderPluginManager.instance().removePlugin(this);
+        break;
+      }
+      default:
+        throw new Error(`Unrecognized Recorder extension endpoint event: ${event}`);
+    }
+  }
+
+  /**
+   * In practice, `recording` is a UserFlow[1], but we avoid defining this type on the
+   * API in order to prevent dependencies between Chrome and puppeteer. Extensions
+   * are responsible for working out potential compatibility issues.
+   *
+   * [1]: https://github.com/puppeteer/replay/blob/main/src/Schema.ts#L245
+   */
+  stringify(recording: Object): Promise<string> {
+    return this.sendRequest(PrivateAPI.RecorderExtensionPluginCommands.Stringify, {recording});
+  }
+}

package/front_end/models/extensions/RecorderPluginManager.ts

@@ -0,0 +1,30 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import type {RecorderExtensionEndpoint} from './RecorderExtensionEndpoint.js';
+
+let instance: RecorderPluginManager|null = null;
+
+export class RecorderPluginManager {
+  #plugins: Set<RecorderExtensionEndpoint> = new Set();
+
+  static instance(): RecorderPluginManager {
+    if (!instance) {
+      instance = new RecorderPluginManager();
+    }
+    return instance;
+  }
+
+  addPlugin(plugin: RecorderExtensionEndpoint): void {
+    this.#plugins.add(plugin);
+  }
+
+  removePlugin(plugin: RecorderExtensionEndpoint): void {
+    this.#plugins.delete(plugin);
+  }
+
+  plugins(): RecorderExtensionEndpoint[] {
+    return Array.from(this.#plugins.values());
+  }
+}

package/front_end/models/extensions/extensions.ts

@@ -7,6 +7,7 @@ import * as ExtensionPanel from './ExtensionPanel.js';
 import * as ExtensionServer from './ExtensionServer.js';
 import * as ExtensionTraceProvider from './ExtensionTraceProvider.js';
 import * as ExtensionView from './ExtensionView.js';
+import * as RecorderPluginManager from './RecorderPluginManager.js';
 
 export {
   ExtensionAPI,
@@ -14,4 +15,5 @@ export {
   ExtensionServer,
   ExtensionTraceProvider,
   ExtensionView,
+  RecorderPluginManager,
 };

package/front_end/models/formatter/FormatterWorkerPool.ts

@@ -4,6 +4,7 @@
 
 import * as Common from '../../core/common/common.js';
 import * as FormatterActions from '../../entrypoints/formatter_worker/FormatterActions.js';  // eslint-disable-line rulesdir/es_modules_import
+export {DefinitionKind, type ScopeTreeNode} from '../../entrypoints/formatter_worker/FormatterActions.js';
 
 const MAX_WORKERS = Math.min(2, navigator.hardwareConcurrency - 1);
 
@@ -140,6 +141,11 @@ export class FormatterWorkerPool {
         .then(result => result || '');
   }
 
+  javaScriptScopeTree(expression: string): Promise<FormatterActions.ScopeTreeNode|null> {
+    return this.runTask(FormatterActions.FormatterActions.JAVASCRIPT_SCOPE_TREE, {content: expression})
+        .then(result => result || null);
+  }
+
   evaluatableJavaScriptSubstring(content: string): Promise<string> {
     return this.runTask(FormatterActions.FormatterActions.EVALUATE_JAVASCRIPT_SUBSTRING, {content: content})
         .then(text => text || '');

package/front_end/models/issues_manager/DeprecationIssue.ts

@@ -181,7 +181,7 @@ const UIStrings = {
    */
   vendorSpecificApi: '{PH1} is vendor-specific. Please use the standard {PH2} instead.',
   /**
-   * @description TODO(crbug.com/1320351): Description needed for translation
+   * @description Warning displayed to developers when `window.webkitStorageInfo` is used to notify that the API is deprecated.
    */
   prefixedStorageInfo:
       '`window.webkitStorageInfo` is deprecated. Please use `navigator.webkitTemporaryStorage` or `navigator.webkitPersistentStorage` instead.',

package/front_end/models/javascript_metadata/JavaScriptMetadata.ts

@@ -10,8 +10,7 @@ let javaScriptMetadataInstance: JavaScriptMetadataImpl;
 
 export class JavaScriptMetadataImpl implements Common.JavaScriptMetaData.JavaScriptMetaData {
   private readonly uniqueFunctions: Map<string, string[][]>;
-  private readonly instanceMethods: Map<string, Map<string, string[][]>>;
-  private readonly staticMethods: Map<string, Map<string, string[][]>>;
+  private readonly receiverMethods: Map<string, Map<string, string[][]>>;
   static instance(opts: {
     forceNew: boolean|null,
   } = {forceNew: null}): JavaScriptMetadataImpl {
@@ -24,26 +23,20 @@ export class JavaScriptMetadataImpl implements Common.JavaScriptMetaData.JavaScr
   }
   constructor() {
     this.uniqueFunctions = new Map();
-    this.instanceMethods = new Map();
-    this.staticMethods = new Map();
+    this.receiverMethods = new Map();
 
     for (const nativeFunction of NativeFunctions) {
-      if (!nativeFunction.receiver) {
+      if (!nativeFunction.receivers) {
         this.uniqueFunctions.set(nativeFunction.name, nativeFunction.signatures);
-      } else if (nativeFunction.static) {
-        let staticMethod = this.staticMethods.get(nativeFunction.receiver);
-        if (!staticMethod) {
-          staticMethod = new Map();
-          this.staticMethods.set(nativeFunction.receiver, staticMethod);
-        }
-        staticMethod.set(nativeFunction.name, nativeFunction.signatures);
-      } else {
-        let instanceMethod = this.instanceMethods.get(nativeFunction.receiver);
-        if (!instanceMethod) {
-          instanceMethod = new Map();
-          this.instanceMethods.set(nativeFunction.receiver, instanceMethod);
+        continue;
+      }
+      for (const receiver of nativeFunction.receivers) {
+        let method = this.receiverMethods.get(receiver);
+        if (!method) {
+          method = new Map();
+          this.receiverMethods.set(receiver, method);
         }
-        instanceMethod.set(nativeFunction.name, nativeFunction.signatures);
+        method.set(nativeFunction.name, nativeFunction.signatures);
       }
     }
   }
@@ -53,7 +46,7 @@ export class JavaScriptMetadataImpl implements Common.JavaScriptMetaData.JavaScr
   }
 
   signaturesForInstanceMethod(name: string, receiverClassName: string): string[][]|null {
-    const instanceMethod = this.instanceMethods.get(receiverClassName);
+    const instanceMethod = this.receiverMethods.get(receiverClassName);
     if (!instanceMethod) {
       return null;
     }
@@ -61,7 +54,7 @@ export class JavaScriptMetadataImpl implements Common.JavaScriptMetaData.JavaScr
   }
 
   signaturesForStaticMethod(name: string, receiverConstructorName: string): string[][]|null {
-    const staticMethod = this.staticMethods.get(receiverConstructorName);
+    const staticMethod = this.receiverMethods.get(receiverConstructorName + 'Constructor');
     if (!staticMethod) {
       return null;
     }