chrome-devtools-frontend 1.0.961797 → 1.0.963960

package/.eslintignore

@@ -5,13 +5,14 @@
 // clang-format check also ignores that file
 front_end/.eslintrc.js
 front_end/diff/diff_match_patch.js
+front_end/generated/protocol.ts
 front_end/javascript_metadata/NativeFunctions.js
 front_end/third_party/
+node_modules
+scripts/migration/**/*.js
+scripts/protocol_typescript/*.js
+test/**/fixtures/
 test/e2e/**/*.js
 test/shared/**/*.js
-test/**/fixtures/
-scripts/protocol_typescript/*.js
-scripts/migration/**/*.js
-node_modules
 
 *.d.ts

package/AUTHORS

@@ -39,6 +39,7 @@ Luke Swiderski <luke.swiderski@gmail.com>
 Marijn Haverbeke <marijnh@gmail.com>
 Michael Brüning <michael.bruning@qt.io>
 Michael Rienstra <mrienstra@gmail.com>
+Paul Fisher <paul@pfish.zone>
 Per-Olov Jernberg <possan@possan.se>
 PhistucK <phistuck@gmail.com>
 Pradhuman Singh Baid <pradhumansinghbaid@gmail.com>

package/config/gni/devtools_grd_files.gni

@@ -659,6 +659,7 @@ grd_files_debug_sources = [
   "front_end/generated/ARIAProperties.js",
   "front_end/generated/InspectorBackendCommands.js",
   "front_end/generated/SupportedCSSProperties.js",
+  "front_end/generated/protocol.js",
   "front_end/legacy_test_runner/test_runner/TestRunner.js",
   "front_end/models/bindings/BreakpointManager.js",
   "front_end/models/bindings/CSSWorkspaceBinding.js",
@@ -735,7 +736,6 @@ grd_files_debug_sources = [
   "front_end/models/persistence/WorkspaceSettingsTab.js",
   "front_end/models/persistence/editFileSystemView.css.js",
   "front_end/models/persistence/workspaceSettingsTab.css.js",
-  "front_end/models/text_utils/CodeMirrorUtils.js",
   "front_end/models/text_utils/ContentProvider.js",
   "front_end/models/text_utils/StaticContentProvider.js",
   "front_end/models/text_utils/Text.js",

package/docs/resource_management.md

@@ -0,0 +1,119 @@
+# Resource management in DevTools
+
+This document outlines how DevTools keeps track of resources like scripts and
+HTML files, and how they interact with other features such as the Debugger.
+The source code lives in the bindings/, persistence/ and workspace/ directories.
+
+## Core concepts and classes
+
+* **Project:** Interface to a collection of resources. DevTools supports
+  different project **types**. For example “filesystem”, for resources
+  originating from the developers local machine, and “network”, for actual page
+  resources. The **Project** interface abstracts away rudimentary file
+  operations. Depending on the **type**, a **Project** may be able to create,
+  rename or delete resources, or change the contents.
+
+* **Workspace**: A collection of all the **Projects** currently in use.
+  Implemented as a singleton in WorkspaceImpl.ts.
+
+* **UISourceCode:** An actual resource identified by its URL. Scripts and
+  stylesheets are prominent examples, but DevTools also uses more esoteric
+  **ResourceTypes** such as XHR, WebSocket or EventSource.
+
+## Project types
+
+A short overview over the different Project types and what **kind of resources**
+they contain.
+
+* **Network:** All resources loaded from the network are stored in network
+  projects. Different targets and/or **Resource** **types** may use different
+  projects. E.g. Each target has their own project containing only JavaScript
+  source maps.
+
+* **Filesystem:** Resources stored on the developers local machine.
+  * Snippets are managed with a single Project just for snippets.
+  * Each local directory mapped into DevTools with the “Workspaces” feature has
+    its own project.
+  * Each directory used for the “Overrides” feature has a corresponding project
+    to manage the local files.
+
+* **Formatter:** A single project of this type manages the formatted version of
+  script resources. That is the “pretty-print” feature for minified JS files.
+
+* **ContentScripts**: Scripts from extensions running in the context of the page
+  itself. One project per target. Source maps for content scripts are managed by
+  separate, per target, projects. The source map projects also have the
+  **ContentScripts** type.
+
+* **Service:** One project of this type per target. It holds placeholder
+  UISourceCodes for source maps while they are loaded. Once a source map
+  finishes loading, the placeholder is removed from the **Service** project.
+
+* **Debugger:** One project of this type per target. Debugger projects store
+  parsed JS scripts (see next section).
+
+## The “Debugger” project type
+
+When V8 parses scripts, it sends out a
+[“Debugger.ScriptParsed”](https://chromedevtools.github.io/devtools-protocol/tot/Debugger/#event-scriptParsed)
+event with some details, including a unique script ID and the URL of the script.
+For each “Debugger.ScriptParsed” event, DevTools creates a **Script** object and
+an associated **UISourceCode** in the “debugger” project. It is important to
+note that the URL of this “debugger” UISourceCode contains both the script ID as
+well as the script name (not URL!) to uniquely identify it. This is because:
+
+_The relationship between network/filesystem UISourceCodes and **Script**
+**objects**/debugger UISourceCodes is 1:n._
+
+For example if the same script is included twice on a page with <script>
+elements, it will result in a single UISourceCode in the **Network** project but
+**two Script** **objects** and two UISourceCodes in the **Debugger** project.
+Similarly, every invocation of a Snippet will result in a separate **Script**
+object per invocation while the Snippet itself is stored in a **Filesystem**
+project.
+
+## Mappings and bindings
+
+As can be seen above, UISourceCodes in different projects can potentially be
+related to one another. A minified script resource in a **scripts Network project**
+might have a pretty-printed version in the **Formatter project** while the
+source map for the minified script is stored in the **source map Network project**.
+Once the minified script is parsed/executed by V8, it also has a corresponding
+**Script object** and a UISourceCode in the **Debugger project**.
+
+This brings us to mappings and bindings. The terminology is roughly:
+
+* _A **binding** ties different UISourceCodes together and determines which
+  UISourceCodes relate to one another._
+* _A **mapping** translates source positions between bound UISourceCodes._
+
+## Binding implementations
+
+There are a couple of classes tasked with establishing bindings between
+UISourceCodes:
+
+* **DebuggerWorkspaceBinding:** Responsible for scripts and source maps.
+  It ties together network/filesystem UISourceCodes with **Script** objects and
+  the debugger USourceCodes. Script source maps are also partially implemented
+  by this class.
+
+* **CSSWorkspaceBinding:** Responsible for CSS and CSS source maps. DevTools can
+  handle source mapped CSS when it was authored in SASS and this class is
+  responsible for binding the corresponding UISourceCodes.
+
+* **PersistenceBinding/PersistenceImpl/Automapping**: Responsible for the
+  [“Workspaces”](https://developer.chrome.com/docs/devtools/workspaces/)
+  feature. When a developer adds a local directory to DevTools that corresponds
+  to the pages sources, these classes establish and manage the binding between
+  the corresponding **Filesystem** and **Network** resources.
+
+* **NetworkPersistenceManager**: Responsible for the
+  [“Local Overrides”](https://developer.chrome.com/blog/new-in-devtools-65/#overrides)
+  feature. It connects the **Network** resources with the corresponding
+  overwritten version in a **Filesystem** project. This class also handles
+  network request interceptions and determines whether to serve the original or
+  the overwritten UISourceCode.
+
+Please keep in mind that many of these classes have gathered additional
+responsibilities over the years, so the concepts presented above might not
+always cleanly apply or be apparent in code.

package/front_end/core/common/ParsedURL.ts

@@ -168,16 +168,17 @@ export class ParsedURL {
   }
 
   static rawPathToUrlString(fileSystemPath: Platform.DevToolsPath.RawPathString): Platform.DevToolsPath.UrlString {
-    let rawPath: string = fileSystemPath;
-    rawPath = rawPath.replace(/\\/g, '/');
-    if (!rawPath.startsWith('file://')) {
-      if (rawPath.startsWith('/')) {
-        rawPath = 'file://' + rawPath;
+    let preEncodedPath: string = ParsedURL.preEncodeSpecialCharactersInPath(
+        fileSystemPath.replace(/\\/g, '/') as Platform.DevToolsPath.RawPathString);
+    preEncodedPath = preEncodedPath.replace(/\\/g, '/');
+    if (!preEncodedPath.startsWith('file://')) {
+      if (preEncodedPath.startsWith('/')) {
+        preEncodedPath = 'file://' + preEncodedPath;
       } else {
-        rawPath = 'file:///' + rawPath;
+        preEncodedPath = 'file:///' + preEncodedPath;
       }
     }
-    return rawPath as Platform.DevToolsPath.UrlString;
+    return new URL(preEncodedPath).toString() as Platform.DevToolsPath.UrlString;
   }
 
   static relativePathToUrlString(relativePath: string, baseURL: Platform.DevToolsPath.UrlString):
@@ -187,13 +188,14 @@ export class ParsedURL {
     return new URL(preEncodedPath, baseURL).toString() as Platform.DevToolsPath.UrlString;
   }
 
-  static capFilePrefix(fileURL: Platform.DevToolsPath.UrlString, isWindows?: boolean):
+  static urlToRawPathString(fileURL: Platform.DevToolsPath.UrlString, isWindows?: boolean):
       Platform.DevToolsPath.RawPathString {
     console.assert(fileURL.startsWith('file://'), 'This must be a file URL.');
+    const decodedFileURL = decodeURIComponent(fileURL);
     if (isWindows) {
-      return fileURL.substr('file:///'.length).replace(/\//g, '\\') as Platform.DevToolsPath.RawPathString;
+      return decodedFileURL.substr('file:///'.length).replace(/\//g, '\\') as Platform.DevToolsPath.RawPathString;
     }
-    return fileURL.substr('file://'.length) as Platform.DevToolsPath.RawPathString;
+    return decodedFileURL.substr('file://'.length) as Platform.DevToolsPath.RawPathString;
   }
 
   static urlWithoutHash(url: string): string {

package/front_end/core/host/UserMetrics.ts

@@ -584,7 +584,8 @@ export enum DevtoolsExperiments {
   'cssTypeComponentLength' = 52,
   'preciseChanges' = 53,
   'bfcacheDisplayTree' = 54,
-  'MaxValue' = 55,
+  'stylesPaneCSSChanges' = 55,
+  'MaxValue' = 56,
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 

package/front_end/core/i18n/locales/en-US.json

@@ -4809,10 +4809,10 @@
     "message": "Copy selector"
   },
   "panels/elements/StylesSidebarPane.ts | cssPropertyName": {
-    "message": "CSS property name"
+    "message": "CSS property name: {PH1}"
   },
   "panels/elements/StylesSidebarPane.ts | cssPropertyValue": {
-    "message": "CSS property value"
+    "message": "CSS property value: {PH1}"
   },
   "panels/elements/StylesSidebarPane.ts | cssSelector": {
     "message": "CSS selector"

package/front_end/core/i18n/locales/en-XL.json

@@ -4809,10 +4809,10 @@
     "message": "Ĉóp̂ý selector"
   },
   "panels/elements/StylesSidebarPane.ts | cssPropertyName": {
-    "message": "CSS p̂ŕôṕêŕt̂ý n̂ám̂é"
+    "message": "CSS p̂ŕôṕêŕt̂ý n̂ám̂é: {PH1}"
   },
   "panels/elements/StylesSidebarPane.ts | cssPropertyValue": {
-    "message": "CSS p̂ŕôṕêŕt̂ý v̂ál̂úê"
+    "message": "CSS p̂ŕôṕêŕt̂ý v̂ál̂úê: {PH1}"
   },
   "panels/elements/StylesSidebarPane.ts | cssSelector": {
     "message": "CSS ŝél̂éĉt́ôŕ"

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -30,7 +30,7 @@
 
 import {NodeURL} from './NodeURL.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
-import * as Protocol from '../../generated/protocol.js';
+import type * as Protocol from '../../generated/protocol.js';
 
 export const DevToolsStubErrorCode = -32015;
 // TODO(dgozman): we are not reporting generic errors in tests, but we should
@@ -147,14 +147,14 @@ export class InspectorBackend {
 
   registerEnum(type: QualifiedName, values: Object): void {
     const [domain, name] = splitQualifiedName(type);
-    // @ts-ignore Protocol global namespace pollution
-    if (!Protocol[domain]) {
-      // @ts-ignore Protocol global namespace pollution
-      Protocol[domain] = {};
+    // @ts-ignore globalThis global namespace pollution
+    if (!globalThis.Protocol[domain]) {
+      // @ts-ignore globalThis global namespace pollution
+      globalThis.Protocol[domain] = {};
     }
 
-    // @ts-ignore Protocol global namespace pollution
-    Protocol[domain][name] = values;
+    // @ts-ignore globalThis global namespace pollution
+    globalThis.Protocol[domain][name] = values;
     this.#initialized = true;
   }
 

package/front_end/core/root/Runtime.ts

@@ -272,6 +272,8 @@ export enum ExperimentName {
   WEBAUTHN_PANE = 'webauthnPane',
   SYNC_SETTINGS = 'syncSettings',
   FULL_ACCESSIBILITY_TREE = 'fullAccessibilityTree',
+  PRECISE_CHANGES = 'preciseChanges',
+  STYLES_PANE_CSS_CHANGES = 'stylesPaneCSSChanges',
 }
 
 // TODO(crbug.com/1167717): Make this a const enum again

package/front_end/core/sdk/CSSProperty.ts

@@ -3,13 +3,10 @@
 // found in the LICENSE file.
 
 import * as TextUtils from '../../models/text_utils/text_utils.js';
-import * as Common from '../common/common.js';
+import type * as Common from '../common/common.js';
 import * as HostModule from '../host/host.js';
-import * as Platform from '../platform/platform.js';
-import * as Root from '../root/root.js';
 import type * as Protocol from '../../generated/protocol.js';
 
-import {cssMetadata, GridAreaRowRegex} from './CSSMetadata.js';
 import type {Edit} from './CSSModel.js';
 import type {CSSStyleDeclaration} from './CSSStyleDeclaration.js';
 
@@ -163,113 +160,17 @@ export class CSSProperty {
     }
 
     const range = this.range.relativeTo(this.ownerStyle.range.startLine, this.ownerStyle.range.startColumn);
-    const indentation = this.ownerStyle.cssText ?
-        this.detectIndentation(this.ownerStyle.cssText) :
-        Common.Settings.Settings.instance().moduleSetting('textEditorIndent').get();
-    const endIndentation = this.ownerStyle.cssText ? indentation.substring(0, this.ownerStyle.range.endColumn) : '';
     const text = new TextUtils.Text.Text(this.ownerStyle.cssText || '');
-    const newStyleText = text.replaceRange(range, Platform.StringUtilities.sprintf(';%s;', propertyText));
-    const tokenizerFactory = TextUtils.CodeMirrorUtils.TokenizerFactory.instance();
-    const styleText = CSSProperty.formatStyle(newStyleText, indentation, endIndentation, tokenizerFactory);
-    return this.ownerStyle.setText(styleText, majorChange);
-  }
-
-  static formatStyle(
-      styleText: string, indentation: string, endIndentation: string,
-      tokenizerFactory: TextUtils.TextUtils.TokenizerFactory): string {
-    const doubleIndent = indentation.substring(endIndentation.length) + indentation;
-    if (indentation) {
-      indentation = '\n' + indentation;
-    }
-    let result = '';
-    let propertyName = '';
-    let propertyText = '';
-    let insideProperty = false;
-    let needsSemi = false;
-    const tokenize = tokenizerFactory.createTokenizer('text/css');
-
-    tokenize('*{' + styleText + '}', processToken);
-    if (insideProperty) {
-      result += propertyText;
-    }
-    result = result.substring(2, result.length - 1).trimRight();
-    return result + (indentation ? '\n' + endIndentation : '');
-
-    function processToken(token: string, tokenType: string|null, _column: number, _newColumn: number): void {
-      if (!insideProperty) {
-        const disabledProperty = tokenType && tokenType.includes('comment') && isDisabledProperty(token);
-        const isPropertyStart = tokenType &&
-            (tokenType.includes('string') || tokenType.includes('meta') || tokenType.includes('property') ||
-             tokenType.includes('variable-2'));
-        if (disabledProperty) {
-          result = result.trimRight() + indentation + token;
-        } else if (isPropertyStart) {
-          insideProperty = true;
-          propertyText = token;
-        } else if (token !== ';' || needsSemi) {
-          result += token;
-          if (token.trim() && !(tokenType && tokenType.includes('comment'))) {
-            needsSemi = token !== ';';
-          }
-        }
-        if (token === '{' && !tokenType) {
-          needsSemi = false;
-        }
-        return;
-      }
-
-      if (token === '}' || token === ';') {
-        // While `propertyText` can generally be trimmed, doing so
-        // breaks valid CSS declarations such as `--foo:  ;` which would
-        // then produce invalid CSS of the form `--foo:;`. This
-        // implementation takes special care to restore a single
-        // whitespace token in this edge case. https://crbug.com/1071296
-        const trimmedPropertyText = propertyText.trim();
-        result =
-            result.trimRight() + indentation + trimmedPropertyText + (trimmedPropertyText.endsWith(':') ? ' ' : '');
-        needsSemi = false;
-        insideProperty = false;
-        propertyName = '';
-        if (Root.Runtime.experiments.isEnabled('preciseChanges')) {
-          result += token;
-          return;
-        }
-        // We preserve the legacy behavior to always add semicolon to
-        // declarations regardless of its original text.
-        result += ';';
-        if (token === '}') {
-          result += '}';
-        }
-      } else {
-        if (cssMetadata().isGridAreaDefiningProperty(propertyName)) {
-          const rowResult = GridAreaRowRegex.exec(token);
-          if (rowResult && rowResult.index === 0 && !propertyText.trimRight().endsWith(']')) {
-            propertyText = propertyText.trimRight() + '\n' + doubleIndent;
-          }
-        }
-        if (!propertyName && token === ':') {
-          propertyName = propertyText;
-        }
-        propertyText += token;
-      }
+    const textBeforeInsertion =
+        text.extract(new TextUtils.TextRange.TextRange(0, 0, range.startLine, range.startColumn));
+    // If we are appending after the last property and that property doesn't have a semicolon at the end
+    // (which is only legal in the last position), then add the semicolon in front of the new text to avoid
+    // CSS parsing errors. However, we shouldn't prepend semicolons on the first line or after a comment.
+    if (textBeforeInsertion.trim().length && !/[;{\/]\s*$/.test(textBeforeInsertion)) {
+      propertyText = ';' + propertyText;
     }
-
-    function isDisabledProperty(text: string): boolean {
-      const colon = text.indexOf(':');
-      if (colon === -1) {
-        return false;
-      }
-      const propertyName = text.substring(2, colon).trim();
-      return cssMetadata().isCSSPropertyName(propertyName);
-    }
-  }
-
-  private detectIndentation(text: string): string {
-    const lines = text.split('\n');
-    if (lines.length < 2) {
-      return '';
-    }
-    return TextUtils.TextUtils.Utils.lineIndent(lines[1]);
+    const newStyleText = text.replaceRange(range, propertyText);
+    return this.ownerStyle.setText(newStyleText, majorChange);
   }
 
   setValue(newValue: string, majorChange: boolean, overwrite: boolean, userCallback?: ((arg0: boolean) => void)): void {
@@ -288,7 +189,18 @@ export class CSSProperty {
       return Promise.resolve(true);
     }
     const propertyText = this.text.trim();
-    const text = disabled ? '/* ' + propertyText + ' */' : this.text.substring(2, propertyText.length - 2).trim();
+    // Ensure that if we try to enable/disable a property that has no semicolon (which is only legal
+    // in the last position of a css rule), we add it. This ensures that if we then later try
+    // to re-enable/-disable the rule, we end up with legal syntax (if the user adds more properties
+    // after the disabled rule).
+    const appendSemicolonIfMissing = (propertyText: string): string =>
+        propertyText + (propertyText.endsWith(';') ? '' : ';');
+    let text: string;
+    if (disabled) {
+      text = '/* ' + appendSemicolonIfMissing(propertyText) + ' */';
+    } else {
+      text = appendSemicolonIfMissing(this.text.substring(2, propertyText.length - 2).trim());
+    }
     return this.setText(text, true, true);
   }
 

package/front_end/core/sdk/DOMModel.ts

@@ -1038,7 +1038,7 @@ export class DOMModel extends SDKModel<EventTypes> {
     this.#pendingDocumentRequestPromise = null;
 
     if (!target.suspended()) {
-      void this.agent.invoke_enable();
+      void this.agent.invoke_enable({});
     }
 
     if (Root.Runtime.experiments.isEnabled('captureNodeCreationStacks')) {
@@ -1497,7 +1497,7 @@ export class DOMModel extends SDKModel<EventTypes> {
   }
 
   async resumeModel(): Promise<void> {
-    await this.agent.invoke_enable();
+    await this.agent.invoke_enable({});
   }
 
   dispose(): void {

package/front_end/core/sdk/DebuggerModel.ts

@@ -425,7 +425,7 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     if (this.target().type() === Type.Node && url.startsWith('file://')) {
       // TODO(crbug.com/1253323): Cast to UrlString will be removed when migration to branded types is complete.
       const platformPath =
-          Common.ParsedURL.ParsedURL.capFilePrefix(url as Platform.DevToolsPath.UrlString, Host.Platform.isWin());
+          Common.ParsedURL.ParsedURL.urlToRawPathString(url as Platform.DevToolsPath.UrlString, Host.Platform.isWin());
       urlRegex =
           `${Platform.StringUtilities.escapeForRegExp(platformPath)}|${Platform.StringUtilities.escapeForRegExp(url)}`;
     }

package/front_end/entrypoints/main/MainImpl.ts

@@ -365,13 +365,18 @@ export class MainImpl {
         'https://developer.chrome.com/blog/new-in-devtools-96/#length');
 
     // Display precise changes in the Changes tab.
-    Root.Runtime.experiments.register('preciseChanges', 'Display more precise changes in the Changes tab');
+    Root.Runtime.experiments.register(
+        Root.Runtime.ExperimentName.PRECISE_CHANGES, 'Display more precise changes in the Changes tab');
+
+    // Integrate CSS changes in the Styles pane.
+    Root.Runtime.experiments.register(
+        Root.Runtime.ExperimentName.STYLES_PANE_CSS_CHANGES, 'Sync CSS changes in the Styles pane');
 
     Root.Runtime.experiments.enableExperimentsByDefault([
       'sourceOrderViewer',
       'hideIssuesFeature',
       'cssTypeComponentLength',
-      'preciseChanges',
+      Root.Runtime.ExperimentName.PRECISE_CHANGES,
       'reportingApiDebugging',
       Root.Runtime.ExperimentName.SYNC_SETTINGS,
     ]);

package/front_end/generated/InspectorBackendCommands.js

@@ -295,7 +295,6 @@ export function registerCommands(inspectorBackend) {
     AttributionReportingIssue: 'AttributionReportingIssue',
     QuirksModeIssue: 'QuirksModeIssue',
     NavigatorUserAgentIssue: 'NavigatorUserAgentIssue',
-    WasmCrossOriginModuleSharingIssue: 'WasmCrossOriginModuleSharingIssue',
     GenericIssue: 'GenericIssue',
     DeprecationIssue: 'DeprecationIssue',
     ClientHintIssue: 'ClientHintIssue'
@@ -681,7 +680,9 @@ export function registerCommands(inspectorBackend) {
   inspectorBackend.registerCommand('DOM.disable', [], []);
   inspectorBackend.registerCommand(
       'DOM.discardSearchResults', [{'name': 'searchId', 'type': 'string', 'optional': false}], []);
-  inspectorBackend.registerCommand('DOM.enable', [], []);
+  inspectorBackend.registerEnum('DOM.EnableRequestIncludeWhitespace', {None: 'none', All: 'all'});
+  inspectorBackend.registerCommand(
+      'DOM.enable', [{'name': 'includeWhitespace', 'type': 'string', 'optional': true}], []);
   inspectorBackend.registerCommand(
       'DOM.focus',
       [
@@ -2114,7 +2115,7 @@ export function registerCommands(inspectorBackend) {
   inspectorBackend.registerEnum(
       'Page.NavigationType', {Navigation: 'Navigation', BackForwardCacheRestore: 'BackForwardCacheRestore'});
   inspectorBackend.registerEnum('Page.BackForwardCacheNotRestoredReason', {
-    NotMainFrame: 'NotMainFrame',
+    NotPrimaryMainFrame: 'NotPrimaryMainFrame',
     BackForwardCacheDisabled: 'BackForwardCacheDisabled',
     RelatedActiveContentsExist: 'RelatedActiveContentsExist',
     HTTPStatusNotOK: 'HTTPStatusNotOK',
@@ -2637,7 +2638,7 @@ export function registerCommands(inspectorBackend) {
   inspectorBackend.registerEvent('Storage.cacheStorageListUpdated', ['origin']);
   inspectorBackend.registerEvent('Storage.indexedDBContentUpdated', ['origin', 'databaseName', 'objectStoreName']);
   inspectorBackend.registerEvent('Storage.indexedDBListUpdated', ['origin']);
-  inspectorBackend.registerEvent('Storage.interestGroupAccessed', ['type', 'ownerOrigin', 'name']);
+  inspectorBackend.registerEvent('Storage.interestGroupAccessed', ['accessTime', 'type', 'ownerOrigin', 'name']);
   inspectorBackend.registerCommand(
       'Storage.clearDataForOrigin',
       [
@@ -3488,6 +3489,9 @@ export function registerCommands(inspectorBackend) {
       []);
   inspectorBackend.registerCommand(
       'Runtime.removeBinding', [{'name': 'name', 'type': 'string', 'optional': false}], []);
+  inspectorBackend.registerCommand(
+      'Runtime.getExceptionDetails', [{'name': 'errorObjectId', 'type': 'string', 'optional': false}],
+      ['exceptionDetails']);
 
   // Schema.
   inspectorBackend.registerCommand('Schema.getDomains', [], ['domains']);

package/front_end/generated/protocol-mapping.d.ts

@@ -1138,7 +1138,7 @@ export namespace ProtocolMapping {
     /**
      * Enables DOM agent for the given page.
      */
-    'DOM.enable': {paramsType: []; returnType: void;};
+    'DOM.enable': {paramsType: [Protocol.DOM.EnableRequest?]; returnType: void;};
     /**
      * Focuses the given element.
      */
@@ -3115,6 +3115,17 @@ export namespace ProtocolMapping {
      * unsubscribes current runtime agent from Runtime.bindingCalled notifications.
      */
     'Runtime.removeBinding': {paramsType: [Protocol.Runtime.RemoveBindingRequest]; returnType: void;};
+    /**
+     * This method tries to lookup and populate exception details for a
+     * JavaScript Error object.
+     * Note that the stackTrace portion of the resulting exceptionDetails will
+     * only be populated if the Runtime domain was enabled at the time when the
+     * Error was thrown.
+     */
+    'Runtime.getExceptionDetails': {
+      paramsType: [Protocol.Runtime.GetExceptionDetailsRequest];
+      returnType: Protocol.Runtime.GetExceptionDetailsResponse;
+    };
     /**
      * Returns supported domains.
      */

package/front_end/generated/protocol-proxy-api.d.ts

@@ -824,7 +824,7 @@ declare namespace ProtocolProxyApi {
     /**
      * Enables DOM agent for the given page.
      */
-    invoke_enable(): Promise<Protocol.ProtocolResponseWithError>;
+    invoke_enable(params: Protocol.DOM.EnableRequest): Promise<Protocol.ProtocolResponseWithError>;
 
     /**
      * Focuses the given element.
@@ -4050,6 +4050,16 @@ declare namespace ProtocolProxyApi {
      * unsubscribes current runtime agent from Runtime.bindingCalled notifications.
      */
     invoke_removeBinding(params: Protocol.Runtime.RemoveBindingRequest): Promise<Protocol.ProtocolResponseWithError>;
+
+    /**
+     * This method tries to lookup and populate exception details for a
+     * JavaScript Error object.
+     * Note that the stackTrace portion of the resulting exceptionDetails will
+     * only be populated if the Runtime domain was enabled at the time when the
+     * Error was thrown.
+     */
+    invoke_getExceptionDetails(params: Protocol.Runtime.GetExceptionDetailsRequest):
+        Promise<Protocol.Runtime.GetExceptionDetailsResponse>;
   }
   export interface RuntimeDispatcher {
     /**

package/front_end/generated/protocol-tsconfig.json

@@ -3,8 +3,8 @@
     "composite": true
   },
   "files": [
-    "protocol.d.ts",
+    "protocol.ts",
     "protocol-mapping.d.ts",
     "protocol-proxy-api.d.ts"
   ]
-}
+}