chrome-devtools-frontend 1.0.1661063 → 1.0.1662289

package/front_end/panels/timeline/ThreadAppender.ts

@@ -87,48 +87,7 @@ const UIStrings = {
    * @example {2} PH1
    */
   threadPoolThreadS: 'Thread pool worker {PH1}',
-  /**
-   * @description Title of a bidder auction worklet with known URL in the timeline flame chart of the Performance panel
-   * @example {https://google.com} PH1
-   */
-  bidderWorkletS: 'Bidder Worklet — {PH1}',
-  /**
-   * @description Title of a bidder auction worklet in the timeline flame chart of the Performance panel with an unknown URL
-   */
-  bidderWorklet: 'Bidder Worklet',
-
-  /**
-   * @description Title of a seller auction worklet in the timeline flame chart of the Performance panel with an unknown URL
-   */
-  sellerWorklet: 'Seller Worklet',
-
-  /**
-   * @description Title of an auction worklet in the timeline flame chart of the Performance panel with an unknown URL
-   */
-  unknownWorklet: 'Auction Worklet',
-
-  /**
-   * @description Title of control thread of a service process for an auction worklet in the timeline flame chart of the Performance panel with an unknown URL
-   */
-  workletService: 'Auction Worklet service',
-
-  /**
-   * @description Title of a seller auction worklet with known URL in the timeline flame chart of the Performance panel
-   * @example {https://google.com} PH1
-   */
-  sellerWorkletS: 'Seller Worklet — {PH1}',
 
-  /**
-   * @description Title of an auction worklet with known URL in the timeline flame chart of the Performance panel
-   * @example {https://google.com} PH1
-   */
-  unknownWorkletS: 'Auction Worklet — {PH1}',
-
-  /**
-   * @description Title of control thread of a service process for an auction worklet with known URL in the timeline flame chart of the Performance panel
-   * @example {https://google.com} PH1
-   */
-  workletServiceS: 'Auction Worklet service — {PH1}',
 } as const;
 
 const str_ = i18n.i18n.registerUIStrings('panels/timeline/ThreadAppender.ts', UIStrings);
@@ -181,12 +140,6 @@ export class ThreadAppender implements TrackAppender {
     this.#threadDefaultName = threadName || i18nString(UIStrings.threadS, {PH1: threadId});
     this.isOnMainFrame = Boolean(this.#parsedTrace.data.Renderer?.processes.get(processId)?.isOnMainFrame);
     this.threadType = type;
-    // AuctionWorklets are threads, so we re-use this appender rather than
-    // duplicate it, but we change the name because we want to render these
-    // lower down than other threads.
-    if (this.#parsedTrace.data.AuctionWorklets.worklets.has(processId)) {
-      this.appenderName = 'Thread_AuctionWorklet';
-    }
     this.#url = this.#parsedTrace.data.Renderer?.processes.get(this.#processId)?.url || '';
   }
 
@@ -279,8 +232,6 @@ export class ThreadAppender implements TrackAppender {
         return VisualLoggingTrackName.THREAD_WORKER;
       case Trace.Handlers.Threads.ThreadType.RASTERIZER:
         return VisualLoggingTrackName.THREAD_RASTERIZER;
-      case Trace.Handlers.Threads.ThreadType.AUCTION_WORKLET:
-        return VisualLoggingTrackName.THREAD_AUCTION_WORKLET;
       case Trace.Handlers.Threads.ThreadType.OTHER:
         return VisualLoggingTrackName.THREAD_OTHER;
       case Trace.Handlers.Threads.ThreadType.CPU_PROFILE:
@@ -350,9 +301,6 @@ export class ThreadAppender implements TrackAppender {
         break;
       case Trace.Handlers.Threads.ThreadType.OTHER:
         break;
-      case Trace.Handlers.Threads.ThreadType.AUCTION_WORKLET:
-        threadTypeLabel = this.#buildNameForAuctionWorklet();
-        break;
       default:
         return Platform.assertNever(this.threadType, `Unknown thread type: ${this.threadType}`);
     }
@@ -371,60 +319,6 @@ export class ThreadAppender implements TrackAppender {
     return this.#entries;
   }
 
-  #buildNameForAuctionWorklet(): string {
-    const workletMetadataEvent = this.#parsedTrace.data.AuctionWorklets.worklets.get(this.#processId);
-    // We should always have this event - if we do not, we were instantiated with invalid data.
-    if (!workletMetadataEvent) {
-      return i18nString(UIStrings.unknownWorklet);
-    }
-
-    // Host could be empty - in which case we do not want to add it.
-    const host = workletMetadataEvent.host ? `https://${workletMetadataEvent.host}` : '';
-    const shouldAddHost = host.length > 0;
-
-    // For each Auction Worklet in a page there are two threads we care about on the same process.
-    // 1. The "Worklet Service" which is a generic helper service. This thread
-    // is always named "auction_worklet.CrUtilityMain".
-    //
-    // 2. The "Seller/Bidder" service. This thread is always named
-    // "AuctionV8HelperThread". The AuctionWorkets handler does the job of
-    // figuring this out for us - the metadata event it provides for each
-    // worklet process will have a `type` already set.
-    //
-    // Therefore, for this given thread, which we know is part of
-    // an AuctionWorklet process, we need to figure out if this thread is the
-    // generic service, or a seller/bidder worklet.
-    //
-    // Note that the worklet could also have the "unknown" type - this is not
-    // expected but implemented to prevent trace event changes causing DevTools
-    // to break with unknown worklet types.
-    const isUtilityThread = workletMetadataEvent.args.data.utilityThread.tid === this.#threadId;
-    const isBidderOrSeller = workletMetadataEvent.args.data.v8HelperThread.tid === this.#threadId;
-
-    if (isUtilityThread) {
-      return shouldAddHost ? i18nString(UIStrings.workletServiceS, {PH1: host}) : i18nString(UIStrings.workletService);
-    }
-
-    if (isBidderOrSeller) {
-      switch (workletMetadataEvent.type) {
-        case Trace.Types.Events.AuctionWorkletType.SELLER:
-          return shouldAddHost ? i18nString(UIStrings.sellerWorkletS, {PH1: host}) :
-                                 i18nString(UIStrings.sellerWorklet);
-        case Trace.Types.Events.AuctionWorkletType.BIDDER:
-          return shouldAddHost ? i18nString(UIStrings.bidderWorkletS, {PH1: host}) :
-                                 i18nString(UIStrings.bidderWorklet);
-        case Trace.Types.Events.AuctionWorkletType.UNKNOWN:
-          return shouldAddHost ? i18nString(UIStrings.unknownWorkletS, {PH1: host}) :
-                                 i18nString(UIStrings.unknownWorklet);
-        default:
-          Platform.assertNever(
-              workletMetadataEvent.type, `Unexpected Auction Worklet Type ${workletMetadataEvent.type}`);
-      }
-    }
-    // We should never reach here, but just in case!
-    return shouldAddHost ? i18nString(UIStrings.unknownWorkletS, {PH1: host}) : i18nString(UIStrings.unknownWorklet);
-  }
-
   #buildNameForWorker(): string {
     const url = this.#parsedTrace.data.Renderer?.processes.get(this.#processId)?.url || '';
     const workerId = this.#parsedTrace.data.Workers.workerIdByThread.get(this.#threadId);

package/front_end/third_party/chromium/README.chromium

@@ -1,7 +1,7 @@
 Name: Dependencies sourced from the upstream `chromium` repository
 URL: Internal
 Version: N/A
-Revision: a37baa84e85d62d8bdc7eef3ff6237217c0c8a9e
+Revision: 27fac8d1924b08d4a6bb70e21df6482a1d430b2b
 Update Mechanism: Manual (https://crbug.com/428069060)
 License: BSD-3-Clause
 License File: LICENSE

package/front_end/ui/components/report_view/ReportView.ts

@@ -55,13 +55,19 @@ export class Report extends HTMLElement {
   #render(): void {
     // Disabled until https://crbug.com/1079231 is fixed.
     // clang-format off
+    const hasToolbar = this.querySelector('[slot="toolbar"]') !== null;
     render(html`
       <style>${reportStyles}</style>
-      ${this.#reportTitle ? html`<h1 class="report-title">
-        ${this.#reportTitle}
-        ${this.#reportUrl ? Components.Linkifier.Linkifier.linkifyURL(this.#reportUrl, {
-          tabStop: true, jslogContext: 'source-location', className: 'report-url'}) : nothing}
-      </h1>` : nothing}
+      ${(this.#reportTitle || hasToolbar) ? html`
+        <div class="report-header-wrapper">
+          ${this.#reportTitle ? html`<h1 class="report-title">
+            ${this.#reportTitle}
+            ${this.#reportUrl ? Components.Linkifier.Linkifier.linkifyURL(this.#reportUrl, {
+              tabStop: true, jslogContext: 'source-location', className: 'report-url'}) : nothing}
+          </h1>` : nothing}
+          <slot name="toolbar"></slot>
+        </div>
+      ` : nothing}
       <div class="content">
         <slot></slot>
       </div>

package/front_end/ui/components/report_view/report.css

@@ -16,13 +16,16 @@
   margin: var(--sys-size-5) 0;
 }
 
+.report-header-wrapper {
+  border-bottom: 1px solid var(--sys-color-divider);
+}
+
 .report-title {
   padding: var(--sys-size-7) var(--sys-size-9);
   font: var(--sys-typescale-headline4);
   white-space: nowrap;
   overflow: hidden;
   text-overflow: ellipsis;
-  border-bottom: 1px solid var(--sys-color-divider);
   color: var(--sys-color-on-surface);
   background-color: var(--sys-color-cdt-base-container);
   margin: 0;

package/front_end/ui/legacy/TextPrompt.ts

@@ -68,7 +68,7 @@ import {cloneCustomElement, ElementFocusRestorer} from './UIUtils.js';
  * @attribute value Sets the initial text value that's edited when editing starts. If not provided, the slot's inner text is used.
  */
 export class TextPromptElement extends HTMLElement {
-  static readonly observedAttributes = ['editing', 'completions', 'placeholder', 'cancel-on-blur'];
+  static readonly observedAttributes = ['editing', 'completions', 'placeholder', 'cancel-on-blur', 'render-as-block'];
   static formAssociated = true;
   readonly #shadow = this.attachShadow({mode: 'open'});
   readonly #internals = this.attachInternals();
@@ -79,6 +79,7 @@ export class TextPromptElement extends HTMLElement {
   #completionObserver = new MutationObserver(this.#onMutate.bind(this));
   #validator?: (value: string) => null | Platform.UIString.LocalizedString;
   #cancelOnBlur = false;
+  #isEditing = false;
 
   constructor() {
     super();
@@ -101,6 +102,18 @@ export class TextPromptElement extends HTMLElement {
     return this.#cancelOnBlur;
   }
 
+  set renderAsBlock(renderAsBlock: boolean) {
+    if (renderAsBlock) {
+      this.setAttribute('render-as-block', '');
+    } else {
+      this.removeAttribute('render-as-block');
+    }
+  }
+
+  get renderAsBlock(): boolean {
+    return this.hasAttribute('render-as-block');
+  }
+
   #onMutate(changes: MutationRecord[]): void {
     const listId = this.getAttribute('completions');
     if (!listId) {
@@ -159,6 +172,17 @@ export class TextPromptElement extends HTMLElement {
           this.#completionObserver.disconnect();
         }
         break;
+      case 'render-as-block':
+        if (this.#isEditing) {
+          if (isTruthy(newValue)) {
+            this.#textPrompt.renderAsBlock();
+            this.#entrypoint.style.display = 'block';
+          } else {
+            this.#textPrompt.renderAsInlineBlock();
+            this.#entrypoint.style.display = 'inline';
+          }
+        }
+        break;
     }
   }
 
@@ -188,6 +212,7 @@ export class TextPromptElement extends HTMLElement {
   }
 
   #startEditing(): void {
+    this.#isEditing = true;
     const truncatedTextPlaceholder = this.getAttribute('placeholder');
     const placeholder = this.#entrypoint.createChild('span');
     const initialText = this.getAttribute('value') ?? this.#slot.deepInnerText();
@@ -198,6 +223,13 @@ export class TextPromptElement extends HTMLElement {
     }
     this.#slot.remove();
 
+    if (this.renderAsBlock) {
+      this.#textPrompt.renderAsBlock();
+      this.#entrypoint.style.display = 'block';
+    } else {
+      this.#textPrompt.renderAsInlineBlock();
+      this.#entrypoint.style.display = 'inline';
+    }
     const proxy =
         this.#textPrompt.attachAndStartEditing(placeholder, e => this.#done(e, /* commit=*/ !this.#cancelOnBlur));
     proxy.addEventListener('keydown', this.#editingValueKeyDown.bind(this));
@@ -206,6 +238,7 @@ export class TextPromptElement extends HTMLElement {
   }
 
   #stopEditing(): void {
+    this.#isEditing = false;
     this.#entrypoint.removeChildren();
     this.#entrypoint.appendChild(this.#slot);
     this.#textPrompt.detach();
@@ -224,6 +257,9 @@ export class TextPromptElement extends HTMLElement {
   }
 
   #done(e: Event, commit: boolean): void {
+    if (!this.#isEditing) {
+      return;
+    }
     const target = e.target as HTMLElement;
     const text = target.textContent || '';
     if (commit) {
@@ -238,9 +274,11 @@ export class TextPromptElement extends HTMLElement {
         return;
       }
 
+      this.#isEditing = false;
       this.dispatchEvent(new TextPromptElement.CommitEvent(text));
     } else {
       this.#internals.setValidity({});
+      this.#isEditing = false;
       this.dispatchEvent(new TextPromptElement.CancelEvent());
     }
     e.consume();
@@ -365,6 +403,16 @@ export class TextPrompt extends Common.ObjectWrapper.ObjectWrapper<EventTypes> i
 
   renderAsBlock(): void {
     this.proxyElementDisplay = 'block';
+    if (this.proxyElement) {
+      (this.proxyElement as HTMLElement).style.display = 'block';
+    }
+  }
+
+  renderAsInlineBlock(): void {
+    this.proxyElementDisplay = 'inline-block';
+    if (this.proxyElement) {
+      (this.proxyElement as HTMLElement).style.display = 'inline-block';
+    }
   }
 
   /**

package/front_end/ui/legacy/UIUtils.ts

@@ -1190,7 +1190,7 @@ export function setTitle(element: HTMLElement, title: string): void {
 }
 
 export class CheckboxLabel extends HTMLElement {
-  static readonly observedAttributes = ['checked', 'disabled', 'indeterminate', 'name', 'title', 'aria-label'];
+  static readonly observedAttributes = ['checked', 'disabled', 'indeterminate', 'name', 'title', 'aria-label', 'small'];
 
   readonly #shadowRoot!: DocumentFragment;
   #checkboxElement!: HTMLInputElement;
@@ -1255,6 +1255,8 @@ export class CheckboxLabel extends HTMLElement {
       this.#textElement.title = newValue ?? '';
     } else if (name === 'aria-label') {
       this.#checkboxElement.ariaLabel = newValue;
+    } else if (name === 'small') {
+      this.#checkboxElement.classList.toggle('small', newValue !== null);
     }
   }
 
@@ -1282,6 +1284,14 @@ export class CheckboxLabel extends HTMLElement {
     this.toggleAttribute('checked', checked);
   }
 
+  get small(): boolean {
+    return this.hasAttribute('small');
+  }
+
+  set small(small: boolean) {
+    this.toggleAttribute('small', small);
+  }
+
   set disabled(disabled: boolean) {
     this.toggleAttribute('disabled', disabled);
   }

package/front_end/ui/legacy/components/cookie_table/CookiesTable.ts

@@ -688,10 +688,10 @@ export class CookiesTable extends UI.Widget.VBox {
       ]);
       void Common.Revealer.reveal(requestFilter);
     }, {jslogContext: 'show-requests-with-this-cookie'});
-    if (IssuesManager.RelatedIssue.hasIssues(cookie)) {
+    if (IssuesManager.RelatedIssue.hasIssues(cookie, IssuesManager.IssuesManager.IssuesManager.instance())) {
       contextMenu.revealSection().appendItem(i18nString(UIStrings.showIssueAssociatedWithThis), () => {
         // TODO(chromium:1077719): Just filter for the cookie instead of revealing one of the associated issues.
-        void IssuesManager.RelatedIssue.reveal(cookie);
+        void IssuesManager.RelatedIssue.reveal(cookie, IssuesManager.IssuesManager.IssuesManager.instance());
       }, {jslogContext: 'show-issue-associated-with-this'});
     }
   }

package/front_end/ui/legacy/textPrompt.css

@@ -24,6 +24,16 @@
   min-width: var(--devtools-text-prompt-min-width, auto);
 }
 
+:host([render-as-block]) .text-prompt-root,
+:host([render-as-block]) .text-prompt {
+  flex: auto;
+  width: 100%;
+}
+
+:host([render-as-block]) .text-prompt:focus {
+  outline: none;
+}
+
 .text-prompt::-webkit-scrollbar {
   display: none;
 }

package/front_end/ui/visual_logging/KnownContextValues.ts

@@ -1353,6 +1353,7 @@ export const knownContextValues = new Set([
   'device-bound-sessions-request',
   'device-bound-sessions-root',
   'device-fold',
+  'device-frame-disable',
   'device-frame-enable',
   'device-mode',
   'device-mode-preset-1024px',

package/package.json

@@ -92,5 +92,5 @@
     "webidl2": "24.5.0",
     "yargs": "17.7.2"
   },
-  "version": "1.0.1661063"
+  "version": "1.0.1662289"
 }

package/front_end/models/trace/handlers/AuctionWorkletsHandler.ts

@@ -1,183 +0,0 @@
-// Copyright 2023 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Helpers from '../helpers/helpers.js';
-import * as Types from '../types/types.js';
-
-/**
- * There are two metadata events that we care about.
- * => AuctionWorkletRunningInProcess tells us which process the Auction Worklet
- *    has taken to run in.
- * => AuctionWorkletDoneWithProcess tells us when the worklet is done with that
- *    process. This is less useful - but in the future we might want to surface
- *    this information so we still parse and return the event.
- *
- * It is important to note that the top level PID on these events is NOT the
- * PID that the worklet is running on; instead we have to look at its
- * args.data.pid property, which is the PID of the process that it is running
- * on.
- *
- * For any given RunningInProcess event, we would typically expect to see a
- * DoneWithProcess event, however this is not guaranteed, especially as users
- * can record any chunk of time in DevTools.
- *
- * Similarly, it is also possible to see a DoneWithProcess event without a
- * RunningInProcess event, if the user started recording after the auction
- * worklets started. Therefore we are happy to create
- * SyntheticAuctionWorklets as long as we see just one of these events.
- *
- * If we do get two events and need to pair them, we can use the
- * args.data.target property, which is a string ID shared by both
- * events.
- */
-let runningInProcessEvents = new Map<Types.Events.ProcessID, Types.Events.AuctionWorkletRunningInProcess>();
-let doneWithProcessEvents = new Map<Types.Events.ProcessID, Types.Events.AuctionWorkletDoneWithProcess>();
-
-// Keyed by the PID defined in  `args.data.pid` on AuctionWorklet trace events..
-let createdSyntheticEvents = new Map<Types.Events.ProcessID, Types.Events.SyntheticAuctionWorklet>();
-
-// Each AuctonWorklet takes over a process and has 2 threads (that we care
-// about and want to show as tracks):
-// 1. A CrUtilityMain thread which is known as the "control process".
-// 2. A AuctionV8HelperThread which is the actual auction worklet and will be
-//    either a "Seller" or a "Bidder"
-// To detect these we look for the metadata thread_name events. We key these by
-// PID so that we can easily look them up later without having to loop through.
-let utilityThreads = new Map<Types.Events.ProcessID, Types.Events.ThreadName>();
-let v8HelperThreads = new Map<Types.Events.ProcessID, Types.Events.ThreadName>();
-
-export function reset(): void {
-  runningInProcessEvents = new Map();
-  doneWithProcessEvents = new Map();
-  createdSyntheticEvents = new Map();
-  utilityThreads = new Map();
-  v8HelperThreads = new Map();
-}
-
-export function handleEvent(event: Types.Events.Event): void {
-  if (Types.Events.isAuctionWorkletRunningInProcess(event)) {
-    runningInProcessEvents.set(event.args.data.pid, event);
-    return;
-  }
-
-  if (Types.Events.isAuctionWorkletDoneWithProcess(event)) {
-    doneWithProcessEvents.set(event.args.data.pid, event);
-    return;
-  }
-
-  if (Types.Events.isThreadName(event)) {
-    if (event.args.name === 'auction_worklet.CrUtilityMain') {
-      utilityThreads.set(event.pid, event);
-      return;
-    }
-    if (event.args.name === 'AuctionV8HelperThread') {
-      v8HelperThreads.set(event.pid, event);
-    }
-  }
-}
-
-function workletType(input: string): Types.Events.AuctionWorkletType {
-  switch (input) {
-    case 'seller':
-      return Types.Events.AuctionWorkletType.SELLER;
-    case 'bidder':
-      return Types.Events.AuctionWorkletType.BIDDER;
-    default:
-      return Types.Events.AuctionWorkletType.UNKNOWN;
-  }
-}
-
-/**
- * We cannot make the full event without knowing the type of event, but we can
- * create everything other than the `args` field, as those are identical
- * regardless of the type of event.
- */
-function makeSyntheticEventBase(
-    event: Types.Events.AuctionWorkletDoneWithProcess|
-    Types.Events.AuctionWorkletRunningInProcess): Omit<Types.Events.SyntheticAuctionWorklet, 'args'> {
-  return Helpers.SyntheticEvents.SyntheticEventsManager
-      .registerSyntheticEvent<Omit<Types.Events.SyntheticAuctionWorklet, 'args'>>({
-        rawSourceEvent: event,
-        name: 'SyntheticAuctionWorklet',
-        s: Types.Events.Scope.THREAD,
-        cat: event.cat,
-        tid: event.tid,
-        ts: event.ts,
-        ph: Types.Events.Phase.INSTANT,
-        pid: event.args.data.pid,
-        host: event.args.data.host,
-        target: event.args.data.target,
-        type: workletType(event.args.data.type),
-      });
-}
-
-export async function finalize(): Promise<void> {
-  // Loop through the utility threads we found to create the worklet events. We
-  // expect each worklet to have a utility thread, so we can use them as the
-  // root of our list of worklets.
-  for (const [pid, utilityThreadNameEvent] of utilityThreads) {
-    const v8HelperEvent = v8HelperThreads.get(pid);
-    if (!v8HelperEvent) {
-      // Bad trace data - AuctionWorklets are expected to always have both threads.
-      continue;
-    }
-
-    const runningEvent = runningInProcessEvents.get(pid);
-    const doneWithEvent = doneWithProcessEvents.get(pid);
-
-    // We can create a worklet from either the runningEvent or doneWithEvent -
-    // we do not need both. We cannot express that to TypeScript with an early
-    // return here, so instead we set the event initially to null, and then
-    // create it from either the running event or the doneWith event. If it is
-    // still null after this, that means neither event was found, and we drop
-    // the worklet as we do not have enough information to create the synthetic
-    // event.
-
-    let syntheticEvent: Types.Events.SyntheticAuctionWorklet|null = null;
-
-    if (runningEvent) {
-      syntheticEvent = {
-        ...makeSyntheticEventBase(runningEvent),
-        args: {
-          data: {
-            runningInProcessEvent: runningEvent,
-            utilityThread: utilityThreadNameEvent,
-            v8HelperThread: v8HelperEvent,
-          },
-        },
-      };
-      if (doneWithEvent) {
-        syntheticEvent.args.data.doneWithProcessEvent = doneWithEvent;
-      }
-    } else if (doneWithEvent) {
-      syntheticEvent = {
-        ...makeSyntheticEventBase(doneWithEvent),
-        args: {
-          data: {
-            doneWithProcessEvent: doneWithEvent,
-            utilityThread: utilityThreadNameEvent,
-            v8HelperThread: v8HelperEvent,
-          },
-        },
-      };
-      if (runningEvent) {
-        syntheticEvent.args.data.runningInProcessEvent = runningEvent;
-      }
-    }
-    if (syntheticEvent === null) {
-      continue;
-    }
-    createdSyntheticEvents.set(pid, syntheticEvent);
-  }
-}
-
-export interface AuctionWorkletsData {
-  worklets: Map<Types.Events.ProcessID, Types.Events.SyntheticAuctionWorklet>;
-}
-
-export function data(): AuctionWorkletsData {
-  return {
-    worklets: createdSyntheticEvents,
-  };
-}

package/front_end/panels/application/InterestGroupStorageModel.ts

@@ -1,81 +0,0 @@
-// Copyright 2021 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as SDK from '../../core/sdk/sdk.js';
-import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
-import type * as Protocol from '../../generated/protocol.js';
-
-export class InterestGroupStorageModel extends SDK.SDKModel.SDKModel<EventTypes> implements
-    ProtocolProxyApi.StorageDispatcher {
-  private readonly storageAgent: ProtocolProxyApi.StorageApi;
-  private enabled?: boolean;
-
-  constructor(target: SDK.Target.Target) {
-    super(target);
-    target.registerStorageDispatcher(this);
-    this.storageAgent = target.storageAgent();
-    this.enabled = false;
-  }
-
-  enable(): void {
-    if (this.enabled) {
-      return;
-    }
-    void this.storageAgent.invoke_setInterestGroupTracking({enable: true});
-  }
-
-  disable(): void {
-    if (!this.enabled) {
-      return;
-    }
-    void this.storageAgent.invoke_setInterestGroupTracking({enable: false});
-  }
-
-  interestGroupAccessed(event: Protocol.Storage.InterestGroupAccessedEvent): void {
-    this.dispatchEventToListeners(Events.INTEREST_GROUP_ACCESS, event);
-  }
-
-  indexedDBListUpdated(_event: Protocol.Storage.IndexedDBListUpdatedEvent): void {
-  }
-
-  indexedDBContentUpdated(_event: Protocol.Storage.IndexedDBContentUpdatedEvent): void {
-  }
-
-  interestGroupAuctionEventOccurred(_event: Protocol.Storage.InterestGroupAuctionEventOccurredEvent): void {
-  }
-
-  interestGroupAuctionNetworkRequestCreated(_event: Protocol.Storage.InterestGroupAuctionNetworkRequestCreatedEvent):
-      void {
-  }
-
-  cacheStorageListUpdated(_event: Protocol.Storage.CacheStorageListUpdatedEvent): void {
-  }
-
-  cacheStorageContentUpdated(_event: Protocol.Storage.CacheStorageContentUpdatedEvent): void {
-  }
-
-  sharedStorageAccessed(_event: Protocol.Storage.SharedStorageAccessedEvent): void {
-  }
-
-  sharedStorageWorkletOperationExecutionFinished(
-      _event: Protocol.Storage.SharedStorageWorkletOperationExecutionFinishedEvent): void {
-  }
-
-  storageBucketCreatedOrUpdated(_event: Protocol.Storage.StorageBucketCreatedOrUpdatedEvent): void {
-  }
-
-  storageBucketDeleted(_event: Protocol.Storage.StorageBucketDeletedEvent): void {
-  }
-}
-
-SDK.SDKModel.SDKModel.register(
-    InterestGroupStorageModel, {capabilities: SDK.Target.Capability.STORAGE, autostart: false});
-
-export const enum Events {
-  INTEREST_GROUP_ACCESS = 'InterestGroupAccess',
-}
-
-export interface EventTypes {
-  [Events.INTEREST_GROUP_ACCESS]: Protocol.Storage.InterestGroupAccessedEvent;
-}