chrome-devtools-frontend 1.0.1657110 → 1.0.1660788

package/front_end/panels/application/StorageView.ts

@@ -58,13 +58,13 @@ const UIStrings = {
    */
   clearSiteData: 'Clear site data',
   /**
-   * @description Announce message when the "clear site data" task is complete
+   * @description Button text in the Storage View of the Application panel for clearing selected site-specific storage
    */
-  SiteDataCleared: 'Site data cleared',
+  clearSelected: 'Clear selected',
   /**
-   * @description Category description in the Clear Storage section of the Storage View of the Application panel
+   * @description Announce message when the "clear site data" task is complete
    */
-  application: 'Application',
+  SiteDataCleared: 'Site data cleared',
   /**
    * @description Checkbox label in the Clear Storage section of the Storage View of the Application panel
    */
@@ -88,7 +88,7 @@ const UIStrings = {
   /**
    * @description Checkbox label in the Clear Storage section of the Storage View of the Application panel
    */
-  includingThirdPartyCookies: 'including third-party cookies',
+  thirdPartyCookies: 'Third-party cookies',
   /**
    * @description Text for error message in Application Quota Override
    * @example {Image} PH1
@@ -155,6 +155,7 @@ export class StorageView extends UI.Widget.VBox {
   private storageKey: string|null;
   private settings: Map<Protocol.Storage.StorageType, Common.Settings.Setting<boolean>>;
   private includeThirdPartyCookiesSetting: Common.Settings.Setting<boolean>;
+  private includeThirdPartyCookiesCheckbox: UI.UIUtils.CheckboxLabel;
   private quotaRow: HTMLElement;
   private quotaUsage: number|null;
   private pieChart: PerfUI.PieChart.PieChart;
@@ -201,16 +202,59 @@ export class StorageView extends UI.Widget.VBox {
     this.includeThirdPartyCookiesSetting =
         Common.Settings.Settings.instance().createSetting('clear-storage-include-third-party-cookies', false);
 
-    const clearButtonSection = this.reportView.appendSection('', 'clear-storage-button').appendRow();
-    this.clearButton = UI.UIUtils.createTextButton(
-        i18nString(UIStrings.clearSiteData), this.clear.bind(this), {jslogContext: 'storage.clear-site-data'});
+    const clearSiteData = this.reportView.appendSection(i18nString(UIStrings.clearSiteData));
+    clearSiteData.element.setAttribute('jslog', `${VisualLogging.section('clear-storage')}`);
+
+    const clearSiteDataCheckboxesRow = clearSiteData.appendRow();
+    clearSiteDataCheckboxesRow.classList.add('clear-site-data-checkboxes-row');
+    const leftColumn = clearSiteDataCheckboxesRow.createChild('div', 'clear-site-data-checkbox-column');
+    this.appendSettingCheckbox(leftColumn, i18nString(UIStrings.cacheStorage),
+                               Protocol.Storage.StorageType.Cache_storage, 'cache-storage-checkbox');
+    this.appendSettingCheckbox(leftColumn, i18nString(UIStrings.indexDB), Protocol.Storage.StorageType.Indexeddb,
+                               'indexeddb-checkbox');
+    this.appendSettingCheckbox(leftColumn, i18nString(UIStrings.localAndSessionStorage),
+                               Protocol.Storage.StorageType.Local_storage, 'local-and-session-storage-checkbox');
+
+    const rightColumn = clearSiteDataCheckboxesRow.createChild('div', 'clear-site-data-checkbox-column');
+    this.appendSettingCheckbox(rightColumn, i18nString(UIStrings.unregisterServiceWorker),
+                               Protocol.Storage.StorageType.Service_workers, 'unregister-service-worker-checkbox');
+    const cookiesCheckbox = this.appendSettingCheckbox(rightColumn, i18nString(UIStrings.cookies),
+                                                       Protocol.Storage.StorageType.Cookies, 'cookies-checkbox');
+    cookiesCheckbox.classList.add('cookies-row');
+
+    const includeThirdPartyCookiesRow = rightColumn.createChild('div', 'include-third-party-cookies-row');
+    this.includeThirdPartyCookiesCheckbox = SettingsUI.SettingsUI.createSettingCheckbox(
+        i18nString(UIStrings.thirdPartyCookies), this.includeThirdPartyCookiesSetting);
+    this.includeThirdPartyCookiesCheckbox.classList.add('third-party-cookies-checkbox');
+    includeThirdPartyCookiesRow.appendChild(this.includeThirdPartyCookiesCheckbox);
+
+    const clearButtonRow = clearSiteData.appendRow();
+    clearButtonRow.classList.add('clear-selected-button-row');
+    this.clearButton = UI.UIUtils.createTextButton(i18nString(UIStrings.clearSelected), this.clear.bind(this),
+                                                   {jslogContext: 'storage.clear-site-data'});
     this.clearButton.id = 'storage-view-clear-button';
-    clearButtonSection.appendChild(this.clearButton);
+    clearButtonRow.appendChild(this.clearButton);
+
+    clearSiteData.markFieldListAsGroup();
 
-    const includeThirdPartyCookiesCheckbox = SettingsUI.SettingsUI.createSettingCheckbox(
-        i18nString(UIStrings.includingThirdPartyCookies), this.includeThirdPartyCookiesSetting);
-    includeThirdPartyCookiesCheckbox.classList.add('include-third-party-cookies');
-    clearButtonSection.appendChild(includeThirdPartyCookiesCheckbox);
+    const cookiesSetting = this.settings.get(Protocol.Storage.StorageType.Cookies);
+    if (cookiesSetting) {
+      cookiesSetting.addChangeListener(event => this.onCookiesSettingChanged(event.data));
+    }
+    this.includeThirdPartyCookiesSetting.addChangeListener(
+        event => this.onIncludeThirdPartyCookiesSettingChanged(event.data));
+    cookiesCheckbox.addEventListener('change', () => {
+      this.syncCheckboxAttributeState(cookiesCheckbox);
+      if (!cookiesCheckbox.checked && this.includeThirdPartyCookiesCheckbox.checked) {
+        this.includeThirdPartyCookiesCheckbox.click();
+      }
+      this.onCookiesSettingChanged(cookiesCheckbox.checked);
+    });
+    this.includeThirdPartyCookiesCheckbox.addEventListener('change', () => {
+      this.syncCheckboxAttributeState(this.includeThirdPartyCookiesCheckbox);
+      this.onIncludeThirdPartyCookiesSettingChanged(this.includeThirdPartyCookiesCheckbox.checked);
+    });
+    this.onCookiesSettingChanged(Boolean(cookiesSetting?.get()));
 
     const quota = this.reportView.appendSection(i18nString(UIStrings.usage));
     quota.element.setAttribute('jslog', `${VisualLogging.section('usage')}`);
@@ -257,31 +301,51 @@ export class StorageView extends UI.Widget.VBox {
     const errorMessageRow = quota.appendRow();
     this.quotaOverrideErrorMessage = errorMessageRow.createChild('div', 'quota-override-error');
 
-    const application = this.reportView.appendSection(i18nString(UIStrings.application));
-    application.element.setAttribute('jslog', `${VisualLogging.section('application')}`);
-    this.appendItem(
-        application, i18nString(UIStrings.unregisterServiceWorker), Protocol.Storage.StorageType.Service_workers);
-    application.markFieldListAsGroup();
-
-    const storage = this.reportView.appendSection(i18nString(UIStrings.storageTitle));
-    storage.element.setAttribute('jslog', `${VisualLogging.section('storage')}`);
-    this.appendItem(storage, i18nString(UIStrings.localAndSessionStorage), Protocol.Storage.StorageType.Local_storage);
-    this.appendItem(storage, i18nString(UIStrings.indexDB), Protocol.Storage.StorageType.Indexeddb);
-    this.appendItem(storage, i18nString(UIStrings.cookies), Protocol.Storage.StorageType.Cookies);
-    this.appendItem(storage, i18nString(UIStrings.cacheStorage), Protocol.Storage.StorageType.Cache_storage);
-    storage.markFieldListAsGroup();
-
     SDK.TargetManager.TargetManager.instance().observeTargets(this);
   }
 
-  private appendItem(
-      section: UI.ReportView.Section, title: Platform.UIString.LocalizedString,
-      settingName: Protocol.Storage.StorageType): void {
-    const row = section.appendRow();
+  private appendSettingCheckbox(container: HTMLElement, title: Platform.UIString.LocalizedString,
+                                settingName: Protocol.Storage.StorageType,
+                                className?: string): UI.UIUtils.CheckboxLabel {
     const setting = this.settings.get(settingName);
-    if (setting) {
-      row.appendChild(SettingsUI.SettingsUI.createSettingCheckbox(title, setting));
+    if (!setting) {
+      throw new Error(`Missing setting for storage type: ${settingName}`);
+    }
+    const checkbox = SettingsUI.SettingsUI.createSettingCheckbox(title, setting);
+    if (className) {
+      checkbox.classList.add(className);
     }
+    container.appendChild(checkbox);
+    return checkbox;
+  }
+
+  private onCookiesSettingChanged(cookiesEnabled: boolean): void {
+    if (!cookiesEnabled) {
+      this.includeThirdPartyCookiesCheckbox.toggleAttribute('checked', true);
+      this.includeThirdPartyCookiesCheckbox.toggleAttribute('checked', false);
+      if (this.includeThirdPartyCookiesSetting.get()) {
+        this.includeThirdPartyCookiesSetting.set(false);
+      }
+    }
+    this.updateThirdPartyCookiesCheckboxState();
+  }
+
+  private onIncludeThirdPartyCookiesSettingChanged(includeThirdPartyCookiesEnabled: boolean): void {
+    const cookiesSetting = this.settings.get(Protocol.Storage.StorageType.Cookies);
+    if (includeThirdPartyCookiesEnabled && cookiesSetting && !cookiesSetting.get()) {
+      cookiesSetting.set(true);
+      return;
+    }
+    this.updateThirdPartyCookiesCheckboxState();
+  }
+
+  private syncCheckboxAttributeState(checkbox: UI.UIUtils.CheckboxLabel): void {
+    checkbox.toggleAttribute('checked', checkbox.checked);
+  }
+
+  private updateThirdPartyCookiesCheckboxState(): void {
+    const cookiesSetting = this.settings.get(Protocol.Storage.StorageType.Cookies);
+    this.includeThirdPartyCookiesCheckbox.disabled = !cookiesSetting?.get();
   }
 
   targetAdded(target: SDK.Target.Target): void {

package/front_end/panels/application/WebMCPView.ts

@@ -194,6 +194,10 @@ const UIStrings = {
    * @description Notice to display when a tool has been unregistered
    */
   toolUnregisteredNotice: 'This tool has been unregistered',
+  /**
+   * @description Label for a list of tool flags or attributes
+   */
+  flags: 'Flags',
 } as const;
 const str_ = i18n.i18n.registerUIStrings('panels/application/WebMCPView.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
@@ -1114,6 +1118,12 @@ const TOOL_DETAILS_VIEW = (input: ToolDetailsViewInput, output: undefined, targe
   }
   const tool = input.tool;
   const origin = input.origin;
+  const flags = tool.flags;
+  const formatter = new Intl.ListFormat(i18n.DevToolsLocale.DevToolsLocale.instance().locale, {
+    style: 'short',
+    type: 'unit',
+  });
+  const formattedFlags = formatter.format(flags);
   render(html`
     <style>${webMCPViewStyles}</style>
     <div class="tool-details-grid">
@@ -1121,6 +1131,10 @@ const TOOL_DETAILS_VIEW = (input: ToolDetailsViewInput, output: undefined, targe
       <div class="value source-code">${tool.name}</div>
       <div class="label">Description</div>
       <div class="value">${tool.description}</div>
+      ${flags.length > 0 ? html`
+      <div class="label">${i18nString(UIStrings.flags)}</div>
+      <div class="value">${formattedFlags}</div>
+      ` : nothing}
       ${tool.frame ? html`
       <div class="label">${i18nString(UIStrings.frame)}</div>
       <div class="value">${Components.Linkifier.Linkifier.linkifyRevealable(tool.frame, tool.frame.displayName())}</div>
@@ -1223,7 +1237,7 @@ export class ToolDetailsWidget extends UI.Widget.Widget {
   };
 
   #clearHighlight = (): void => {
-    SDK.OverlayModel.OverlayModel.hideDOMNodeHighlight();
+    SDK.OverlayModel.OverlayModel.hideDOMNodeHighlight(SDK.TargetManager.TargetManager.instance());
   };
 
   #revealNode = (node: SDK.DOMModel.DOMNode): void => {

package/front_end/panels/application/components/AdsView.ts

@@ -80,7 +80,7 @@ const DEFAULT_VIEW: View = (input, output, target) => {
   };
 
   const formatCpu = (val: number): string => {
-    return i18n.TimeUtilities.preciseMillisToString(val, 1);
+    return i18n.TimeUtilities.millisToString(val);
   };
 
   const formatNetwork = (val: number): string => {

package/front_end/panels/application/indexedDBViews.css

@@ -10,36 +10,37 @@
   border-bottom: 1px solid var(--sys-color-divider);
 }
 
-.indexed-db-data-view .data-grid {
+.indexed-db-data-view devtools-data-grid {
+  border: 0;
   flex: auto;
 }
 
-.indexed-db-data-view .data-grid .data-container tr:nth-last-child(1) {
+:host-context(.indexed-db-data-view) .data-grid .data-container tr:nth-last-child(1) {
   background-color: var(--sys-color-cdt-base-container);
 }
 
-.indexed-db-data-view .data-grid .data-container tr:nth-last-child(1) td {
+:host-context(.indexed-db-data-view) .data-grid .data-container tr:nth-last-child(1) td {
   border: 0;
 }
 
-.indexed-db-data-view .data-grid .data-container tr:nth-last-child(2) td {
+:host-context(.indexed-db-data-view) .data-grid .data-container tr:nth-last-child(2) td {
   border-bottom: 1px solid var(--sys-color-divider);
 }
 
-.indexed-db-data-view .data-grid:focus .data-container tr.selected {
+:host-context(.indexed-db-data-view) .data-grid:focus .data-container tr.selected {
   background-color: var(--sys-color-tonal-container);
   color: inherit;
 }
 
-.indexed-db-data-view .section,
-.indexed-db-data-view .section > .header,
-.indexed-db-data-view .section > .header .title {
+:host-context(.indexed-db-data-view) .section,
+:host-context(.indexed-db-data-view) .section > .header,
+:host-context(.indexed-db-data-view) .section > .header .title {
   margin: 0;
   min-height: inherit;
   line-height: inherit;
 }
 
-.indexed-db-data-view .data-grid .data-container td .section .header .title {
+:host-context(.indexed-db-data-view) .data-grid .data-container td .section .header .title {
   white-space: nowrap;
   text-overflow: ellipsis;
   overflow: hidden;
@@ -79,3 +80,31 @@
   text-overflow: ellipsis;
   overflow: hidden;
 }
+
+.object-store-summary-bar .separator {
+  padding: 0 0.5em;
+}
+
+.key-filter-input {
+  flex-grow: 0.5;
+}
+
+.stale-data-warning {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 0 4px;
+}
+
+.stale-data-warning .warning-icon {
+  --icon-color: var(--icon-warning);
+
+  width: 20px;
+  height: 20px;
+}
+
+.data-grid-container {
+  flex: auto;
+  display: flex;
+  flex-direction: column;
+}

package/front_end/panels/application/preloading/helper/PreloadingForward.ts

@@ -54,7 +54,8 @@ function prefetchStatusCode(requestId: Protocol.Network.RequestId): number|undef
  * Retrieves the HTTP status code for a prerender attempt.
  */
 function prerenderStatusCode(loaderId: Protocol.Network.LoaderId): number|undefined {
-  const frame = SDK.ResourceTreeModel.ResourceTreeModel.frames().find(f => f.loaderId === loaderId);
+  const frame = SDK.ResourceTreeModel.ResourceTreeModel.frames(SDK.TargetManager.TargetManager.instance())
+                    .find(f => f.loaderId === loaderId);
   if (!frame) {
     return undefined;
   }

package/front_end/panels/application/resourcesSidebar.css

@@ -75,3 +75,8 @@ devtools-icon.navigator-font-tree-item {
 .tree-outline li:hover .ai-button-container {
   display: inline-flex;
 }
+
+.tree-outline li.ads-tree-element .trailing-icons {
+  margin-left: auto;
+  margin-right: var(--sys-size-2);
+}

package/front_end/panels/application/storageView.css

@@ -14,8 +14,24 @@
   }
 }
 
-.clear-storage-button .report-row {
-  display: flex;
+.clear-site-data-checkboxes-row {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: var(--sys-size-5) var(--sys-size-10);
+  align-items: start;
+}
+
+.clear-site-data-checkbox-column {
+  display: grid;
+  row-gap: var(--sys-size-5);
+
+  > devtools-checkbox {
+    margin-left: 0;
+  }
+}
+
+.clear-selected-button-row {
+  margin-top: var(--sys-size-7);
 }
 
 .link {
@@ -67,17 +83,18 @@
 
 .clear-storage-header {
   min-width: 400px;
+  /* Keep in sync with ui/legacy/checkboxTextLabel.css (12px input, 6px margins). */
+  --nested-checkbox-indent: 24px;
 }
 
 .report-content-box {
   overflow: initial;
 }
 
-.include-third-party-cookies {
-  flex: 1;
-  min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  margin-left: 10px;
+.include-third-party-cookies-row {
+  margin-left: var(--nested-checkbox-indent);
+
+  > devtools-checkbox {
+    margin-left: 0;
+  }
 }

package/front_end/panels/browser_debugger/XHRBreakpointsSidebarPane.ts

@@ -65,7 +65,7 @@ const containerToBreakpointEntry = new WeakMap<Element, HTMLElement>();
 
 const breakpointEntryToCheckbox = new WeakMap<Element, UI.UIUtils.CheckboxLabel>();
 
-let xhrBreakpointsSidebarPaneInstance: XHRBreakpointsSidebarPane;
+let xhrBreakpointsSidebarPaneInstance: XHRBreakpointsSidebarPane|null = null;
 
 export class XHRBreakpointsSidebarPane extends UI.Widget.VBox implements UI.ContextFlavorListener.ContextFlavorListener,
                                                                          UI.Toolbar.ItemsProvider,
@@ -117,6 +117,10 @@ export class XHRBreakpointsSidebarPane extends UI.Widget.VBox implements UI.Cont
     return xhrBreakpointsSidebarPaneInstance;
   }
 
+  static removeInstance(): void {
+    xhrBreakpointsSidebarPaneInstance = null;
+  }
+
   toolbarItems(): UI.Toolbar.ToolbarItem[] {
     return [this.#addButton];
   }

package/front_end/panels/browser_debugger/browser_debugger-meta.ts

@@ -202,9 +202,10 @@ UI.ViewManager.registerViewExtension({
   commandPrompt: i18nLazyString(UIStrings.showPage),
   order: 2,
   persistence: UI.ViewManager.ViewPersistence.PERMANENT,
-  async loadView() {
+  async loadView(universe) {
     const Sources = await loadSourcesModule();
-    return Sources.SourcesNavigator.NetworkNavigatorView.instance();
+    return Sources.SourcesNavigator.NetworkNavigatorView.instance(
+        {forceNew: null, networkProjectManager: universe.networkProjectManager});
   },
 });
 
@@ -216,9 +217,10 @@ UI.ViewManager.registerViewExtension({
   order: 4,
   persistence: UI.ViewManager.ViewPersistence.PERMANENT,
   condition: () => !Root.Runtime.Runtime.isTraceApp(),
-  async loadView() {
+  async loadView(universe) {
     const Sources = await loadSourcesModule();
-    return Sources.SourcesNavigator.OverridesNavigatorView.instance();
+    return Sources.SourcesNavigator.OverridesNavigatorView.instance(
+        {forceNew: null, networkProjectManager: universe.networkProjectManager});
   },
 });
 
@@ -230,9 +232,9 @@ UI.ViewManager.registerViewExtension({
   order: 5,
   persistence: UI.ViewManager.ViewPersistence.PERMANENT,
   condition: () => Root.Runtime.getPathName() !== '/bundled/worker_app.html' && !Root.Runtime.Runtime.isTraceApp(),
-  async loadView() {
+  async loadView(universe) {
     const Sources = await loadSourcesModule();
-    return new Sources.SourcesNavigator.ContentScriptsNavigatorView();
+    return new Sources.SourcesNavigator.ContentScriptsNavigatorView(universe.networkProjectManager);
   },
 });
 

package/front_end/panels/common/DOMLinkifier.ts

@@ -134,7 +134,7 @@ export class DOMNodeLink extends UI.Widget.Widget {
         this.#node?.highlight?.();
       },
       onMouseLeave: () => {
-        SDK.OverlayModel.OverlayModel.hideDOMNodeHighlight();
+        SDK.OverlayModel.OverlayModel.hideDOMNodeHighlight(SDK.TargetManager.TargetManager.instance());
       },
       ariaDescription: options.ariaDescription,
     };

package/front_end/panels/common/ExtensionServer.ts

@@ -337,7 +337,8 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
       throw new Error('Received a message from an unregistered extension');
     }
     const endpoint = new Extensions.LanguageExtensionEndpoint.LanguageExtensionEndpoint(
-        registration.allowFileAccess, extensionOrigin, pluginName, {language, symbol_types: symbol_types_array}, port);
+        registration.allowFileAccess, extensionOrigin, pluginName, {language, symbol_types: symbol_types_array}, port,
+        pluginManager);
     pluginManager.addPlugin(endpoint);
     return this.status.OK();
   }
@@ -563,6 +564,7 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
       return;
     }
     this.requests = new Map();
+    this.clearExtensionHeaders(event.data.inspectedURL());
     this.enableExtensions();
     const url = event.data.inspectedURL();
     this.postNotification(Extensions.ExtensionAPI.PrivateAPI.Events.InspectedURLChanged, [url]);
@@ -664,16 +666,7 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     for (const name in message.headers) {
       extensionHeaders.set(name, message.headers[name]);
     }
-    const allHeaders = ({} as Protocol.Network.Headers);
-    for (const headers of this.extraHeaders.values()) {
-      for (const [name, value] of headers) {
-        if (name !== '__proto__' && typeof value === 'string') {
-          allHeaders[name] = value;
-        }
-      }
-    }
-
-    SDK.NetworkManager.MultitargetNetworkManager.instance().setExtraHTTPHeaders(allHeaders);
+    this.syncExtraHeaders();
     return undefined;
   }
 
@@ -1085,6 +1078,58 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     return this.evaluate(expression, true, true, evaluateOptions, this.getExtensionOrigin(port), callback.bind(this));
   }
 
+  private harEntryReferencesBlockedURL(entry: HAR.Log.EntryDTO, extension: RegisteredExtension): boolean {
+    const baseURL = entry.request.url;
+
+    // Helper to cleanly resolve and check permission
+    const isBlocked = (url: string|undefined): boolean => {
+      if (!url) {
+        return false;
+      }
+      try {
+        const absoluteURL = new URL(url, baseURL).toString() as Platform.DevToolsPath.UrlString;
+        return !extension.isAllowedOnTarget(absoluteURL);
+      } catch {
+        return true;  // Fallback safely: treat unparsable URLs as blocked
+      }
+    };
+
+    if (isBlocked(entry.response.redirectURL)) {
+      return true;
+    }
+    if (entry._initiator) {
+      if (isBlocked(entry._initiator.url)) {
+        return true;
+      }
+      let stack = entry._initiator.stack;
+      while (stack) {
+        if (stack.callFrames.some(f => isBlocked(f.url))) {
+          return true;
+        }
+        stack = stack.parent;
+      }
+    }
+    for (const header of entry.response.headers) {
+      const name = header.name.toLowerCase();
+      if (name === 'location' || name === 'content-location') {
+        if (isBlocked(header.value)) {
+          return true;
+        }
+      } else if (name === 'refresh') {
+        const match = header.value.match(/;\s*url\s*=\s*(.+)$/i);
+        if (isBlocked(match?.[1]?.trim())) {
+          return true;
+        }
+      } else if (name === 'link') {
+        const urls = [...header.value.matchAll(/<([^>]+)>/g)].map(m => m[1]);
+        if (urls.some(url => isBlocked(url))) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   private async onGetHAR(message: Extensions.ExtensionAPI.PrivateAPI.ExtensionServerRequestMessage, port: MessagePort):
       Promise<Record|HAR.Log.LogDTO> {
     if (message.command !== Extensions.ExtensionAPI.PrivateAPI.Commands.GetHAR) {
@@ -1093,10 +1138,16 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     const requests =
         Logs.NetworkLog.NetworkLog.instance().requests().filter(r => this.extensionAllowedOnContentProvider(r, port));
     const harLog = await HAR.Log.Log.build(requests, {sanitize: false});
+    const extension = this.registeredExtensions.get(this.getExtensionOrigin(port));
+    if (!extension) {
+      return this.status.E_FAILED('Extension disconnected');
+    }
+
     for (let i = 0; i < harLog.entries.length; ++i) {
       // @ts-expect-error
       harLog.entries[i]._requestId = this.requestId(requests[i]);
     }
+    harLog.entries = harLog.entries.filter(entry => !this.harEntryReferencesBlockedURL(entry, extension));
     return harLog;
   }
 
@@ -1236,7 +1287,8 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     }
     const {uiSourceCode} = resource;
     if (!uiSourceCode.contentType().isDocumentOrScriptOrStyleSheet()) {
-      const resource = SDK.ResourceTreeModel.ResourceTreeModel.resourceForURL(url as Platform.DevToolsPath.UrlString);
+      const resource = SDK.ResourceTreeModel.ResourceTreeModel.resourceForURL(
+          SDK.TargetManager.TargetManager.instance(), url as Platform.DevToolsPath.UrlString);
       if (!resource) {
         return this.status.E_NOTFOUND(url);
       }
@@ -1360,6 +1412,13 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
 
   private async notifyRequestFinished(event: Common.EventTarget.EventTargetEvent<SDK.NetworkRequest.NetworkRequest>):
       Promise<void> {
+    if (!this.extensionsEnabled) {
+      return;
+    }
+    if (!this.subscribers.has(Extensions.ExtensionAPI.PrivateAPI.Events.NetworkRequestFinished)) {
+      return;
+    }
+
     const request = event.data;
     const entry = await HAR.Log.Entry.build(request, {sanitize: false});
     const networkManager = SDK.NetworkManager.NetworkManager.forRequest(request);
@@ -1367,7 +1426,8 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     this.postNotification(
         Extensions.ExtensionAPI.PrivateAPI.Events.NetworkRequestFinished, [this.requestId(request), entry],
         extension => extension.isAllowedOnTarget(entry.request.url as Platform.DevToolsPath.UrlString) &&
-            (!targetUrl || extension.isAllowedOnTarget(targetUrl)));
+            (!targetUrl || extension.isAllowedOnTarget(targetUrl)) &&
+            !this.harEntryReferencesBlockedURL(entry, extension));
   }
 
   private notifyElementsSelectionChanged(): void {
@@ -1584,7 +1644,7 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
         found = (frame.url === url) ? frame : null;
         return found;
       }
-      SDK.ResourceTreeModel.ResourceTreeModel.frames().some(hasMatchingURL);
+      SDK.ResourceTreeModel.ResourceTreeModel.frames(SDK.TargetManager.TargetManager.instance()).some(hasMatchingURL);
       return found;
     }
 
@@ -1719,11 +1779,56 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
 
   private disableExtensions(): void {
     this.extensionsEnabled = false;
+    this.clearExtensionHeaders();
   }
 
   private enableExtensions(): void {
     this.extensionsEnabled = true;
   }
+
+  /**
+   * Clear extension-injected HTTP headers that should not persist after
+   * navigation to a disallowed URL. Optionally pass the new inspected URL
+   * to selectively clear only headers from extensions not allowed on that URL;
+   * when omitted, all extension headers are cleared unconditionally.
+   */
+  private clearExtensionHeaders(inspectedURL?: Platform.DevToolsPath.UrlString): void {
+    if (this.extraHeaders.size === 0) {
+      return;
+    }
+    let cleared = false;
+    if (inspectedURL) {
+      for (const id of this.extraHeaders.keys()) {
+        const extension = this.registeredExtensions.get(id);
+        if (!extension || !extension.isAllowedOnTarget(inspectedURL)) {
+          this.extraHeaders.delete(id);
+          cleared = true;
+        }
+      }
+    } else {
+      this.extraHeaders.clear();
+      cleared = true;
+    }
+    if (cleared) {
+      this.syncExtraHeaders();
+    }
+  }
+
+  /**
+   * Collect all extension-injected headers into a single object and push
+   * them to the network layer.
+   */
+  private syncExtraHeaders(): void {
+    const allHeaders: Protocol.Network.Headers = Object.create(null);
+    for (const headers of this.extraHeaders.values()) {
+      for (const [name, value] of headers) {
+        if (typeof value === 'string') {
+          allHeaders[name] = value;
+        }
+      }
+    }
+    SDK.NetworkManager.MultitargetNetworkManager.instance().setExtraHTTPHeaders(allHeaders);
+  }
 }
 
 export const enum Events {