chrome-devtools-frontend 1.0.976570 → 1.0.977952

package/front_end/core/sdk/CSSModel.ts

@@ -265,12 +265,12 @@ export class CSSModel extends SDKModel<EventTypes> {
     await this.agent.invoke_stopRuleUsageTracking();
   }
 
-  async mediaQueriesPromise(): Promise<CSSMedia[]> {
+  async getMediaQueries(): Promise<CSSMedia[]> {
     const {medias} = await this.agent.invoke_getMediaQueries();
     return medias ? CSSMedia.parseMediaArrayPayload(this, medias) : [];
   }
 
-  async rootLayerPromise(nodeId: Protocol.DOM.NodeId): Promise<Protocol.CSS.CSSLayerData> {
+  async getRootLayer(nodeId: Protocol.DOM.NodeId): Promise<Protocol.CSS.CSSLayerData> {
     const {rootLayer} = await this.agent.invoke_getLayersForNode({nodeId});
     return rootLayer;
   }
@@ -288,7 +288,7 @@ export class CSSModel extends SDKModel<EventTypes> {
     this.dispatchEventToListeners(Events.ModelWasEnabled);
   }
 
-  async matchedStylesPromise(nodeId: Protocol.DOM.NodeId): Promise<CSSMatchedStyles|null> {
+  async getMatchedStyles(nodeId: Protocol.DOM.NodeId): Promise<CSSMatchedStyles|null> {
     const response = await this.agent.invoke_getMatchedStylesForNode({nodeId});
 
     if (response.getError()) {
@@ -306,16 +306,16 @@ export class CSSModel extends SDKModel<EventTypes> {
         response.cssKeyframesRules || []);
   }
 
-  async classNamesPromise(styleSheetId: Protocol.CSS.StyleSheetId): Promise<string[]> {
+  async getClassNames(styleSheetId: Protocol.CSS.StyleSheetId): Promise<string[]> {
     const {classNames} = await this.agent.invoke_collectClassNames({styleSheetId});
     return classNames || [];
   }
 
-  computedStylePromise(nodeId: Protocol.DOM.NodeId): Promise<Map<string, string>|null> {
+  getComputedStyle(nodeId: Protocol.DOM.NodeId): Promise<Map<string, string>|null> {
     return this.#styleLoader.computedStylePromise(nodeId);
   }
 
-  async backgroundColorsPromise(nodeId: Protocol.DOM.NodeId): Promise<ContrastInfo|null> {
+  async getBackgroundColors(nodeId: Protocol.DOM.NodeId): Promise<ContrastInfo|null> {
     const response = await this.agent.invoke_getBackgroundColors({nodeId});
     if (response.getError()) {
       return null;
@@ -328,7 +328,7 @@ export class CSSModel extends SDKModel<EventTypes> {
     };
   }
 
-  async platformFontsPromise(nodeId: Protocol.DOM.NodeId): Promise<Protocol.CSS.PlatformFontUsage[]|null> {
+  async getPlatformFonts(nodeId: Protocol.DOM.NodeId): Promise<Protocol.CSS.PlatformFontUsage[]|null> {
     const {fonts} = await this.agent.invoke_getPlatformFontsForNode({nodeId});
     return fonts;
   }
@@ -349,7 +349,7 @@ export class CSSModel extends SDKModel<EventTypes> {
     return values;
   }
 
-  async inlineStylesPromise(nodeId: Protocol.DOM.NodeId): Promise<InlineStyleResult|null> {
+  async getInlineStyles(nodeId: Protocol.DOM.NodeId): Promise<InlineStyleResult|null> {
     const response = await this.agent.invoke_getInlineStylesForNode({nodeId});
 
     if (response.getError() || !response.inlineStyle) {
@@ -702,7 +702,7 @@ export class CSSModel extends SDKModel<EventTypes> {
     this.#cachedMatchedCascadeNode = node;
     if (!this.#cachedMatchedCascadePromise) {
       if (node.id) {
-        this.#cachedMatchedCascadePromise = this.matchedStylesPromise(node.id);
+        this.#cachedMatchedCascadePromise = this.getMatchedStyles(node.id);
       } else {
         return Promise.resolve(null);
       }

package/front_end/generated/InspectorBackendCommands.js

@@ -182,7 +182,7 @@ export function registerCommands(inspectorBackend) {
       []);
 
   // Audits.
-  inspectorBackend.registerEnum('Audits.SameSiteCookieExclusionReason', {
+  inspectorBackend.registerEnum('Audits.CookieExclusionReason', {
     ExcludeSameSiteUnspecifiedTreatedAsLax: 'ExcludeSameSiteUnspecifiedTreatedAsLax',
     ExcludeSameSiteNoneInsecure: 'ExcludeSameSiteNoneInsecure',
     ExcludeSameSiteLax: 'ExcludeSameSiteLax',
@@ -190,7 +190,7 @@ export function registerCommands(inspectorBackend) {
     ExcludeInvalidSameParty: 'ExcludeInvalidSameParty',
     ExcludeSamePartyCrossPartyContext: 'ExcludeSamePartyCrossPartyContext'
   });
-  inspectorBackend.registerEnum('Audits.SameSiteCookieWarningReason', {
+  inspectorBackend.registerEnum('Audits.CookieWarningReason', {
     WarnSameSiteUnspecifiedCrossSiteContext: 'WarnSameSiteUnspecifiedCrossSiteContext',
     WarnSameSiteNoneInsecure: 'WarnSameSiteNoneInsecure',
     WarnSameSiteUnspecifiedLaxAllowUnsafe: 'WarnSameSiteUnspecifiedLaxAllowUnsafe',
@@ -198,9 +198,10 @@ export function registerCommands(inspectorBackend) {
     WarnSameSiteStrictCrossDowngradeStrict: 'WarnSameSiteStrictCrossDowngradeStrict',
     WarnSameSiteStrictCrossDowngradeLax: 'WarnSameSiteStrictCrossDowngradeLax',
     WarnSameSiteLaxCrossDowngradeStrict: 'WarnSameSiteLaxCrossDowngradeStrict',
-    WarnSameSiteLaxCrossDowngradeLax: 'WarnSameSiteLaxCrossDowngradeLax'
+    WarnSameSiteLaxCrossDowngradeLax: 'WarnSameSiteLaxCrossDowngradeLax',
+    WarnAttributeValueExceedsMaxSize: 'WarnAttributeValueExceedsMaxSize'
   });
-  inspectorBackend.registerEnum('Audits.SameSiteCookieOperation', {SetCookie: 'SetCookie', ReadCookie: 'ReadCookie'});
+  inspectorBackend.registerEnum('Audits.CookieOperation', {SetCookie: 'SetCookie', ReadCookie: 'ReadCookie'});
   inspectorBackend.registerEnum('Audits.MixedContentResolutionStatus', {
     MixedContentBlocked: 'MixedContentBlocked',
     MixedContentAutomaticallyUpgraded: 'MixedContentAutomaticallyUpgraded',
@@ -301,7 +302,7 @@ export function registerCommands(inspectorBackend) {
     Canceled: 'Canceled'
   });
   inspectorBackend.registerEnum('Audits.InspectorIssueCode', {
-    SameSiteCookieIssue: 'SameSiteCookieIssue',
+    CookieIssue: 'CookieIssue',
     MixedContentIssue: 'MixedContentIssue',
     BlockedByResponseIssue: 'BlockedByResponseIssue',
     HeavyAdIssue: 'HeavyAdIssue',

package/front_end/generated/protocol.ts

@@ -696,7 +696,7 @@ export namespace Audits {
     frameId: Page.FrameId;
   }
 
-  export const enum SameSiteCookieExclusionReason {
+  export const enum CookieExclusionReason {
     ExcludeSameSiteUnspecifiedTreatedAsLax = 'ExcludeSameSiteUnspecifiedTreatedAsLax',
     ExcludeSameSiteNoneInsecure = 'ExcludeSameSiteNoneInsecure',
     ExcludeSameSiteLax = 'ExcludeSameSiteLax',
@@ -705,7 +705,7 @@ export namespace Audits {
     ExcludeSamePartyCrossPartyContext = 'ExcludeSamePartyCrossPartyContext',
   }
 
-  export const enum SameSiteCookieWarningReason {
+  export const enum CookieWarningReason {
     WarnSameSiteUnspecifiedCrossSiteContext = 'WarnSameSiteUnspecifiedCrossSiteContext',
     WarnSameSiteNoneInsecure = 'WarnSameSiteNoneInsecure',
     WarnSameSiteUnspecifiedLaxAllowUnsafe = 'WarnSameSiteUnspecifiedLaxAllowUnsafe',
@@ -714,9 +714,10 @@ export namespace Audits {
     WarnSameSiteStrictCrossDowngradeLax = 'WarnSameSiteStrictCrossDowngradeLax',
     WarnSameSiteLaxCrossDowngradeStrict = 'WarnSameSiteLaxCrossDowngradeStrict',
     WarnSameSiteLaxCrossDowngradeLax = 'WarnSameSiteLaxCrossDowngradeLax',
+    WarnAttributeValueExceedsMaxSize = 'WarnAttributeValueExceedsMaxSize',
   }
 
-  export const enum SameSiteCookieOperation {
+  export const enum CookieOperation {
     SetCookie = 'SetCookie',
     ReadCookie = 'ReadCookie',
   }
@@ -726,7 +727,7 @@ export namespace Audits {
    * time finding a specific cookie. With this, we can convey specific error
    * information without the cookie.
    */
-  export interface SameSiteCookieIssueDetails {
+  export interface CookieIssueDetails {
     /**
      * If AffectedCookie is not set then rawCookieLine contains the raw
      * Set-Cookie header string. This hints at a problem where the
@@ -735,13 +736,13 @@ export namespace Audits {
      */
     cookie?: AffectedCookie;
     rawCookieLine?: string;
-    cookieWarningReasons: SameSiteCookieWarningReason[];
-    cookieExclusionReasons: SameSiteCookieExclusionReason[];
+    cookieWarningReasons: CookieWarningReason[];
+    cookieExclusionReasons: CookieExclusionReason[];
     /**
      * Optionally identifies the site-for-cookies and the cookie url, which
      * may be used by the front-end as additional context.
      */
-    operation: SameSiteCookieOperation;
+    operation: CookieOperation;
     siteForCookies?: string;
     cookieUrl?: string;
     request?: AffectedRequest;
@@ -1096,7 +1097,7 @@ export namespace Audits {
    * information about the kind of issue.
    */
   export const enum InspectorIssueCode {
-    SameSiteCookieIssue = 'SameSiteCookieIssue',
+    CookieIssue = 'CookieIssue',
     MixedContentIssue = 'MixedContentIssue',
     BlockedByResponseIssue = 'BlockedByResponseIssue',
     HeavyAdIssue = 'HeavyAdIssue',
@@ -1120,7 +1121,7 @@ export namespace Audits {
    * add a new optional field to this type.
    */
   export interface InspectorIssueDetails {
-    sameSiteCookieIssueDetails?: SameSiteCookieIssueDetails;
+    cookieIssueDetails?: CookieIssueDetails;
     mixedContentIssueDetails?: MixedContentIssueDetails;
     blockedByResponseIssueDetails?: BlockedByResponseIssueDetails;
     heavyAdIssueDetails?: HeavyAdIssueDetails;

package/front_end/models/issues_manager/{SameSiteCookieIssue.ts → CookieIssue.ts}

@@ -34,15 +34,14 @@ const UIStrings = {
    */
   firstPartySetsExplained: '`First-Party Sets` and the `SameParty` attribute',
 };
-const str_ = i18n.i18n.registerUIStrings('models/issues_manager/SameSiteCookieIssue.ts', UIStrings);
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/CookieIssue.ts', UIStrings);
 const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
 
-export class SameSiteCookieIssue extends Issue {
-  #issueDetails: Protocol.Audits.SameSiteCookieIssueDetails;
+export class CookieIssue extends Issue {
+  #issueDetails: Protocol.Audits.CookieIssueDetails;
 
   constructor(
-      code: string, issueDetails: Protocol.Audits.SameSiteCookieIssueDetails,
-      issuesModel: SDK.IssuesModel.IssuesModel) {
+      code: string, issueDetails: Protocol.Audits.CookieIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel) {
     super(code, issuesModel);
     this.#issueDetails = issueDetails;
   }
@@ -62,35 +61,34 @@ export class SameSiteCookieIssue extends Issue {
   }
 
   /**
-   * Returns an array of issues from a given SameSiteCookieIssueDetails.
+   * Returns an array of issues from a given CookieIssueDetails.
    */
-  static createIssuesFromSameSiteDetails(
-      sameSiteDetails: Protocol.Audits.SameSiteCookieIssueDetails,
-      issuesModel: SDK.IssuesModel.IssuesModel): SameSiteCookieIssue[] {
-    const issues: SameSiteCookieIssue[] = [];
+  static createIssuesFromCookieIssueDetails(
+      cookieIssueDetails: Protocol.Audits.CookieIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel): CookieIssue[] {
+    const issues: CookieIssue[] = [];
 
     // Exclusion reasons have priority. It means a cookie was blocked. Create an issue
     // for every exclusion reason but ignore warning reasons if the cookie was blocked.
     // Some exclusion reasons are dependent on warning reasons existing in order to produce an issue.
-    if (sameSiteDetails.cookieExclusionReasons && sameSiteDetails.cookieExclusionReasons.length > 0) {
-      for (const exclusionReason of sameSiteDetails.cookieExclusionReasons) {
-        const code = SameSiteCookieIssue.codeForSameSiteDetails(
-            exclusionReason, sameSiteDetails.cookieWarningReasons, sameSiteDetails.operation,
-            sameSiteDetails.cookieUrl);
+    if (cookieIssueDetails.cookieExclusionReasons && cookieIssueDetails.cookieExclusionReasons.length > 0) {
+      for (const exclusionReason of cookieIssueDetails.cookieExclusionReasons) {
+        const code = CookieIssue.codeForCookieIssueDetails(
+            exclusionReason, cookieIssueDetails.cookieWarningReasons, cookieIssueDetails.operation,
+            cookieIssueDetails.cookieUrl);
         if (code) {
-          issues.push(new SameSiteCookieIssue(code, sameSiteDetails, issuesModel));
+          issues.push(new CookieIssue(code, cookieIssueDetails, issuesModel));
         }
       }
       return issues;
     }
 
-    if (sameSiteDetails.cookieWarningReasons) {
-      for (const warningReason of sameSiteDetails.cookieWarningReasons) {
+    if (cookieIssueDetails.cookieWarningReasons) {
+      for (const warningReason of cookieIssueDetails.cookieWarningReasons) {
         // warningReasons should be an empty array here.
-        const code = SameSiteCookieIssue.codeForSameSiteDetails(
-            warningReason, [], sameSiteDetails.operation, sameSiteDetails.cookieUrl);
+        const code = CookieIssue.codeForCookieIssueDetails(
+            warningReason, [], cookieIssueDetails.operation, cookieIssueDetails.cookieUrl);
         if (code) {
-          issues.push(new SameSiteCookieIssue(code, sameSiteDetails, issuesModel));
+          issues.push(new CookieIssue(code, cookieIssueDetails, issuesModel));
         }
       }
     }
@@ -99,36 +97,35 @@ export class SameSiteCookieIssue extends Issue {
 
   /**
    * Calculates an issue code from a reason, an operation, and an array of warningReasons. All these together
-   * can uniquely identify a specific SameSite cookie issue.
-   * warningReasons is only needed for some SameSiteCookieExclusionReason in order to determine if an issue should be raised.
-   * It is not required if reason is a SameSiteCookieWarningReason.
+   * can uniquely identify a specific cookie issue.
+   * warningReasons is only needed for some CookieExclusionReason in order to determine if an issue should be raised.
+   * It is not required if reason is a CookieWarningReason.
    */
-  static codeForSameSiteDetails(
-      reason: Protocol.Audits.SameSiteCookieExclusionReason|Protocol.Audits.SameSiteCookieWarningReason,
-      warningReasons: Protocol.Audits.SameSiteCookieWarningReason[], operation: Protocol.Audits.SameSiteCookieOperation,
+  static codeForCookieIssueDetails(
+      reason: Protocol.Audits.CookieExclusionReason|Protocol.Audits.CookieWarningReason,
+      warningReasons: Protocol.Audits.CookieWarningReason[], operation: Protocol.Audits.CookieOperation,
       cookieUrl?: string): string|null {
     const isURLSecure = cookieUrl && (cookieUrl.startsWith('https://') || cookieUrl.startsWith('wss://'));
     const secure = isURLSecure ? 'Secure' : 'Insecure';
 
-    if (reason === Protocol.Audits.SameSiteCookieExclusionReason.ExcludeSameSiteStrict ||
-        reason === Protocol.Audits.SameSiteCookieExclusionReason.ExcludeSameSiteLax ||
-        reason === Protocol.Audits.SameSiteCookieExclusionReason.ExcludeSameSiteUnspecifiedTreatedAsLax) {
+    if (reason === Protocol.Audits.CookieExclusionReason.ExcludeSameSiteStrict ||
+        reason === Protocol.Audits.CookieExclusionReason.ExcludeSameSiteLax ||
+        reason === Protocol.Audits.CookieExclusionReason.ExcludeSameSiteUnspecifiedTreatedAsLax) {
       if (warningReasons && warningReasons.length > 0) {
-        if (warningReasons.includes(Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteStrictLaxDowngradeStrict)) {
+        if (warningReasons.includes(Protocol.Audits.CookieWarningReason.WarnSameSiteStrictLaxDowngradeStrict)) {
           return [
-            Protocol.Audits.InspectorIssueCode.SameSiteCookieIssue,
+            Protocol.Audits.InspectorIssueCode.CookieIssue,
             'ExcludeNavigationContextDowngrade',
             secure,
           ].join('::');
         }
 
-        if (warningReasons.includes(
-                Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteStrictCrossDowngradeStrict) ||
-            warningReasons.includes(Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteStrictCrossDowngradeLax) ||
-            warningReasons.includes(Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteLaxCrossDowngradeStrict) ||
-            warningReasons.includes(Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteLaxCrossDowngradeLax)) {
+        if (warningReasons.includes(Protocol.Audits.CookieWarningReason.WarnSameSiteStrictCrossDowngradeStrict) ||
+            warningReasons.includes(Protocol.Audits.CookieWarningReason.WarnSameSiteStrictCrossDowngradeLax) ||
+            warningReasons.includes(Protocol.Audits.CookieWarningReason.WarnSameSiteLaxCrossDowngradeStrict) ||
+            warningReasons.includes(Protocol.Audits.CookieWarningReason.WarnSameSiteLaxCrossDowngradeLax)) {
           return [
-            Protocol.Audits.InspectorIssueCode.SameSiteCookieIssue,
+            Protocol.Audits.InspectorIssueCode.CookieIssue,
             'ExcludeContextDowngrade',
             operation,
             secure,
@@ -138,8 +135,8 @@ export class SameSiteCookieIssue extends Issue {
 
       // If we have ExcludeSameSiteUnspecifiedTreatedAsLax but no corresponding warnings, then add just
       // the Issue code for ExcludeSameSiteUnspecifiedTreatedAsLax.
-      if (reason === Protocol.Audits.SameSiteCookieExclusionReason.ExcludeSameSiteUnspecifiedTreatedAsLax) {
-        return [Protocol.Audits.InspectorIssueCode.SameSiteCookieIssue, reason, operation].join('::');
+      if (reason === Protocol.Audits.CookieExclusionReason.ExcludeSameSiteUnspecifiedTreatedAsLax) {
+        return [Protocol.Audits.InspectorIssueCode.CookieIssue, reason, operation].join('::');
       }
 
       // ExcludeSameSiteStrict and ExcludeSameSiteLax require being paired with an appropriate warning. We didn't
@@ -147,18 +144,17 @@ export class SameSiteCookieIssue extends Issue {
       return null;
     }
 
-    if (reason === Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteStrictLaxDowngradeStrict) {
-      return [Protocol.Audits.InspectorIssueCode.SameSiteCookieIssue, reason, secure].join('::');
+    if (reason === Protocol.Audits.CookieWarningReason.WarnSameSiteStrictLaxDowngradeStrict) {
+      return [Protocol.Audits.InspectorIssueCode.CookieIssue, reason, secure].join('::');
     }
     // These have the same message.
-    if (reason === Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteStrictCrossDowngradeStrict ||
-        reason === Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteStrictCrossDowngradeLax ||
-        reason === Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteLaxCrossDowngradeLax ||
-        reason === Protocol.Audits.SameSiteCookieWarningReason.WarnSameSiteLaxCrossDowngradeStrict) {
-      return [Protocol.Audits.InspectorIssueCode.SameSiteCookieIssue, 'WarnCrossDowngrade', operation, secure].join(
-          '::');
+    if (reason === Protocol.Audits.CookieWarningReason.WarnSameSiteStrictCrossDowngradeStrict ||
+        reason === Protocol.Audits.CookieWarningReason.WarnSameSiteStrictCrossDowngradeLax ||
+        reason === Protocol.Audits.CookieWarningReason.WarnSameSiteLaxCrossDowngradeLax ||
+        reason === Protocol.Audits.CookieWarningReason.WarnSameSiteLaxCrossDowngradeStrict) {
+      return [Protocol.Audits.InspectorIssueCode.CookieIssue, 'WarnCrossDowngrade', operation, secure].join('::');
     }
-    return [Protocol.Audits.InspectorIssueCode.SameSiteCookieIssue, reason, operation].join('::');
+    return [Protocol.Audits.InspectorIssueCode.CookieIssue, reason, operation].join('::');
   }
 
   cookies(): Iterable<Protocol.Audits.AffectedCookie> {
@@ -183,7 +179,7 @@ export class SameSiteCookieIssue extends Issue {
   }
 
   getCategory(): IssueCategory {
-    return IssueCategory.SameSiteCookie;
+    return IssueCategory.Cookie;
   }
 
   getDescription(): MarkdownIssueDescription|null {
@@ -207,14 +203,14 @@ export class SameSiteCookieIssue extends Issue {
   }
 
   static fromInspectorIssue(issuesModel: SDK.IssuesModel.IssuesModel, inspectorIssue: Protocol.Audits.InspectorIssue):
-      SameSiteCookieIssue[] {
-    const sameSiteDetails = inspectorIssue.details.sameSiteCookieIssueDetails;
-    if (!sameSiteDetails) {
-      console.warn('SameSite issue without details received.');
+      CookieIssue[] {
+    const cookieIssueDetails = inspectorIssue.details.cookieIssueDetails;
+    if (!cookieIssueDetails) {
+      console.warn('Cookie issue without details received.');
       return [];
     }
 
-    return SameSiteCookieIssue.createIssuesFromSameSiteDetails(sameSiteDetails, issuesModel);
+    return CookieIssue.createIssuesFromCookieIssueDetails(cookieIssueDetails, issuesModel);
   }
 }
 
@@ -431,32 +427,32 @@ const samePartyCrossPartyContextSet: LazyMarkdownIssueDescription = {
 };
 
 const issueDescriptions: Map<string, LazyMarkdownIssueDescription> = new Map([
-  ['SameSiteCookieIssue::ExcludeSameSiteUnspecifiedTreatedAsLax::ReadCookie', sameSiteUnspecifiedErrorRead],
-  ['SameSiteCookieIssue::ExcludeSameSiteUnspecifiedTreatedAsLax::SetCookie', sameSiteUnspecifiedErrorSet],
+  ['CookieIssue::ExcludeSameSiteUnspecifiedTreatedAsLax::ReadCookie', sameSiteUnspecifiedErrorRead],
+  ['CookieIssue::ExcludeSameSiteUnspecifiedTreatedAsLax::SetCookie', sameSiteUnspecifiedErrorSet],
   // These two don't have a deprecation date yet, but they need to be fixed eventually.
-  ['SameSiteCookieIssue::WarnSameSiteUnspecifiedLaxAllowUnsafe::ReadCookie', sameSiteUnspecifiedWarnRead],
-  ['SameSiteCookieIssue::WarnSameSiteUnspecifiedLaxAllowUnsafe::SetCookie', sameSiteUnspecifiedWarnSet],
-  ['SameSiteCookieIssue::WarnSameSiteUnspecifiedCrossSiteContext::ReadCookie', sameSiteUnspecifiedWarnRead],
-  ['SameSiteCookieIssue::WarnSameSiteUnspecifiedCrossSiteContext::SetCookie', sameSiteUnspecifiedWarnSet],
-  ['SameSiteCookieIssue::ExcludeSameSiteNoneInsecure::ReadCookie', sameSiteNoneInsecureErrorRead],
-  ['SameSiteCookieIssue::ExcludeSameSiteNoneInsecure::SetCookie', sameSiteNoneInsecureErrorSet],
-  ['SameSiteCookieIssue::WarnSameSiteNoneInsecure::ReadCookie', sameSiteNoneInsecureWarnRead],
-  ['SameSiteCookieIssue::WarnSameSiteNoneInsecure::SetCookie', sameSiteNoneInsecureWarnSet],
-  ['SameSiteCookieIssue::WarnSameSiteStrictLaxDowngradeStrict::Secure', sameSiteWarnStrictLaxDowngradeStrict(true)],
-  ['SameSiteCookieIssue::WarnSameSiteStrictLaxDowngradeStrict::Insecure', sameSiteWarnStrictLaxDowngradeStrict(false)],
-  ['SameSiteCookieIssue::WarnCrossDowngrade::ReadCookie::Secure', sameSiteWarnCrossDowngradeRead(true)],
-  ['SameSiteCookieIssue::WarnCrossDowngrade::ReadCookie::Insecure', sameSiteWarnCrossDowngradeRead(false)],
-  ['SameSiteCookieIssue::WarnCrossDowngrade::SetCookie::Secure', sameSiteWarnCrossDowngradeSet(true)],
-  ['SameSiteCookieIssue::WarnCrossDowngrade::SetCookie::Insecure', sameSiteWarnCrossDowngradeSet(false)],
-  ['SameSiteCookieIssue::ExcludeNavigationContextDowngrade::Secure', sameSiteExcludeNavigationContextDowngrade(true)],
+  ['CookieIssue::WarnSameSiteUnspecifiedLaxAllowUnsafe::ReadCookie', sameSiteUnspecifiedWarnRead],
+  ['CookieIssue::WarnSameSiteUnspecifiedLaxAllowUnsafe::SetCookie', sameSiteUnspecifiedWarnSet],
+  ['CookieIssue::WarnSameSiteUnspecifiedCrossSiteContext::ReadCookie', sameSiteUnspecifiedWarnRead],
+  ['CookieIssue::WarnSameSiteUnspecifiedCrossSiteContext::SetCookie', sameSiteUnspecifiedWarnSet],
+  ['CookieIssue::ExcludeSameSiteNoneInsecure::ReadCookie', sameSiteNoneInsecureErrorRead],
+  ['CookieIssue::ExcludeSameSiteNoneInsecure::SetCookie', sameSiteNoneInsecureErrorSet],
+  ['CookieIssue::WarnSameSiteNoneInsecure::ReadCookie', sameSiteNoneInsecureWarnRead],
+  ['CookieIssue::WarnSameSiteNoneInsecure::SetCookie', sameSiteNoneInsecureWarnSet],
+  ['CookieIssue::WarnSameSiteStrictLaxDowngradeStrict::Secure', sameSiteWarnStrictLaxDowngradeStrict(true)],
+  ['CookieIssue::WarnSameSiteStrictLaxDowngradeStrict::Insecure', sameSiteWarnStrictLaxDowngradeStrict(false)],
+  ['CookieIssue::WarnCrossDowngrade::ReadCookie::Secure', sameSiteWarnCrossDowngradeRead(true)],
+  ['CookieIssue::WarnCrossDowngrade::ReadCookie::Insecure', sameSiteWarnCrossDowngradeRead(false)],
+  ['CookieIssue::WarnCrossDowngrade::SetCookie::Secure', sameSiteWarnCrossDowngradeSet(true)],
+  ['CookieIssue::WarnCrossDowngrade::SetCookie::Insecure', sameSiteWarnCrossDowngradeSet(false)],
+  ['CookieIssue::ExcludeNavigationContextDowngrade::Secure', sameSiteExcludeNavigationContextDowngrade(true)],
   [
-    'SameSiteCookieIssue::ExcludeNavigationContextDowngrade::Insecure',
+    'CookieIssue::ExcludeNavigationContextDowngrade::Insecure',
     sameSiteExcludeNavigationContextDowngrade(false),
   ],
-  ['SameSiteCookieIssue::ExcludeContextDowngrade::ReadCookie::Secure', sameSiteExcludeContextDowngradeRead(true)],
-  ['SameSiteCookieIssue::ExcludeContextDowngrade::ReadCookie::Insecure', sameSiteExcludeContextDowngradeRead(false)],
-  ['SameSiteCookieIssue::ExcludeContextDowngrade::SetCookie::Secure', sameSiteExcludeContextDowngradeSet(true)],
-  ['SameSiteCookieIssue::ExcludeContextDowngrade::SetCookie::Insecure', sameSiteExcludeContextDowngradeSet(false)],
-  ['SameSiteCookieIssue::ExcludeInvalidSameParty::SetCookie', sameSiteInvalidSameParty],
-  ['SameSiteCookieIssue::ExcludeSamePartyCrossPartyContext::SetCookie', samePartyCrossPartyContextSet],
+  ['CookieIssue::ExcludeContextDowngrade::ReadCookie::Secure', sameSiteExcludeContextDowngradeRead(true)],
+  ['CookieIssue::ExcludeContextDowngrade::ReadCookie::Insecure', sameSiteExcludeContextDowngradeRead(false)],
+  ['CookieIssue::ExcludeContextDowngrade::SetCookie::Secure', sameSiteExcludeContextDowngradeSet(true)],
+  ['CookieIssue::ExcludeContextDowngrade::SetCookie::Insecure', sameSiteExcludeContextDowngradeSet(false)],
+  ['CookieIssue::ExcludeInvalidSameParty::SetCookie', sameSiteInvalidSameParty],
+  ['CookieIssue::ExcludeSamePartyCrossPartyContext::SetCookie', samePartyCrossPartyContextSet],
 ]);

package/front_end/models/issues_manager/Issue.ts

@@ -44,7 +44,7 @@ export enum IssueCategory {
   CrossOriginEmbedderPolicy = 'CrossOriginEmbedderPolicy',
   Generic = 'Generic',
   MixedContent = 'MixedContent',
-  SameSiteCookie = 'SameSiteCookie',
+  Cookie = 'Cookie',
   HeavyAd = 'HeavyAd',
   ContentSecurityPolicy = 'ContentSecurityPolicy',
   TrustedWebActivity = 'TrustedWebActivity',

package/front_end/models/issues_manager/IssuesManager.ts

@@ -22,7 +22,7 @@ import {LowTextContrastIssue} from './LowTextContrastIssue.js';
 import {MixedContentIssue} from './MixedContentIssue.js';
 import {NavigatorUserAgentIssue} from './NavigatorUserAgentIssue.js';
 import {QuirksModeIssue} from './QuirksModeIssue.js';
-import {SameSiteCookieIssue} from './SameSiteCookieIssue.js';
+import {CookieIssue} from './CookieIssue.js';
 import {SharedArrayBufferIssue} from './SharedArrayBufferIssue.js';
 import {SourceFrameIssuesManager} from './SourceFrameIssuesManager.js';
 import {TrustedWebActivityIssue} from './TrustedWebActivityIssue.js';
@@ -49,8 +49,8 @@ const issueCodeHandlers = new Map<
     Protocol.Audits.InspectorIssueCode,
     (model: SDK.IssuesModel.IssuesModel, inspectorIssue: Protocol.Audits.InspectorIssue) => Issue[]>([
   [
-    Protocol.Audits.InspectorIssueCode.SameSiteCookieIssue,
-    SameSiteCookieIssue.fromInspectorIssue,
+    Protocol.Audits.InspectorIssueCode.CookieIssue,
+    CookieIssue.fromInspectorIssue,
   ],
   [
     Protocol.Audits.InspectorIssueCode.MixedContentIssue,
@@ -117,12 +117,6 @@ const issueCodeHandlers = new Map<
  */
 function createIssuesFromProtocolIssue(
     issuesModel: SDK.IssuesModel.IssuesModel, inspectorIssue: Protocol.Audits.InspectorIssue): Issue[] {
-  if (inspectorIssue.code.toString() === 'CookieIssue') {
-    // TODO: backward compatibility for the next chromium roll
-    const details = inspectorIssue.details as {cookieIssueDetails: Protocol.Audits.SameSiteCookieIssueDetails};
-    inspectorIssue.code = Protocol.Audits.InspectorIssueCode.SameSiteCookieIssue;
-    inspectorIssue.details.sameSiteCookieIssueDetails = details.cookieIssueDetails;
-  }
   const handler = issueCodeHandlers.get(inspectorIssue.code);
   if (handler) {
     return handler(issuesModel, inspectorIssue);

package/front_end/models/issues_manager/NavigatorUserAgentIssue.ts

@@ -8,7 +8,7 @@ import type * as Protocol from '../../generated/protocol.js';
 
 import {Issue, IssueCategory, IssueKind} from './Issue.js';
 import type {MarkdownIssueDescription} from './MarkdownIssueDescription.js';
-import {isCausedByThirdParty} from './SameSiteCookieIssue.js';
+import {isCausedByThirdParty} from './CookieIssue.js';
 
 const UIStrings = {
   /**

package/front_end/models/issues_manager/issues_manager.ts

@@ -6,6 +6,7 @@ import * as AttributionReportingIssue from './AttributionReportingIssue.js';
 import * as ClientHintIssue from './ClientHintIssue.js';
 import * as ContentSecurityPolicyIssue from './ContentSecurityPolicyIssue.js';
 import * as ContrastCheckTrigger from './ContrastCheckTrigger.js';
+import * as CookieIssue from './CookieIssue.js';
 import * as CorsIssue from './CorsIssue.js';
 import * as CrossOriginEmbedderPolicyIssue from './CrossOriginEmbedderPolicyIssue.js';
 import * as DeprecationIssue from './DeprecationIssue.js';
@@ -20,7 +21,6 @@ import * as MixedContentIssue from './MixedContentIssue.js';
 import * as NavigatorUserAgentIssue from './NavigatorUserAgentIssue.js';
 import * as QuirksModeIssue from './QuirksModeIssue.js';
 import * as RelatedIssue from './RelatedIssue.js';
-import * as SameSiteCookieIssue from './SameSiteCookieIssue.js';
 import * as SharedArrayBufferIssue from './SharedArrayBufferIssue.js';
 import * as SourceFrameIssuesManager from './SourceFrameIssuesManager.js';
 import * as TrustedWebActivityIssue from './TrustedWebActivityIssue.js';
@@ -30,6 +30,7 @@ export {
   ClientHintIssue,
   ContentSecurityPolicyIssue,
   ContrastCheckTrigger,
+  CookieIssue,
   CorsIssue,
   CrossOriginEmbedderPolicyIssue,
   DeprecationIssue,
@@ -44,7 +45,6 @@ export {
   NavigatorUserAgentIssue,
   QuirksModeIssue,
   RelatedIssue,
-  SameSiteCookieIssue,
   SharedArrayBufferIssue,
   SourceFrameIssuesManager,
   TrustedWebActivityIssue,

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -372,7 +372,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   async generateHeaderPatterns(uiSourceCode: Workspace.UISourceCode.UISourceCode):
       Promise<{headerPatterns: Set<string>, path: string, overridesWithRegex: HeaderOverrideWithRegex[]}> {
     const headerPatterns = new Set<string>();
-    const content = (await uiSourceCode.requestContent()).content || '';
+    const content = (await uiSourceCode.requestContent()).content || '[]';
     let headerOverrides: HeaderOverride[] = [];
     try {
       headerOverrides = JSON.parse(content) as HeaderOverride[];
@@ -421,7 +421,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     await this.#innerUpdateInterceptionPatterns();
   }
 
-  private updateInterceptionPatterns(): void {
+  updateInterceptionPatterns(): void {
     void this.updateInterceptionThrottler.schedule(this.#innerUpdateInterceptionPatterns.bind(this));
   }
 
@@ -657,7 +657,7 @@ export type EventTypes = {
   [Events.ProjectChanged]: Workspace.Workspace.Project|null,
 };
 
-interface HeaderOverride {
+export interface HeaderOverride {
   applyTo: string;
   headers: Protocol.Network.Headers;
 }
@@ -668,7 +668,7 @@ interface HeaderOverrideWithRegex {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function isHeaderOverride(arg: any): arg is HeaderOverride {
+export function isHeaderOverride(arg: any): arg is HeaderOverride {
   if (!(arg && arg.applyTo && typeof (arg.applyTo === 'string') && arg.headers && Object.keys(arg.headers).length)) {
     return false;
   }

package/front_end/panels/application/ApplicationPanelCacheSection.ts

@@ -7,6 +7,7 @@ import * as i18n from '../../core/i18n/i18n.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as UI from '../../ui/legacy/legacy.js';
 import * as ApplicationComponents from './components/components.js';
+import * as Host from '../../core/host/host.js';
 
 import {ApplicationPanelTreeElement, ExpandableApplicationPanelTreeElement} from './ApplicationPanelTreeElement.js';
 import type {ResourcesPanel} from './ResourcesPanel.js';
@@ -164,6 +165,7 @@ export class SWCacheTreeElement extends ApplicationPanelTreeElement {
     }
 
     this.showView(this.view);
+    Host.userMetrics.panelShown(Host.UserMetrics.PanelCodes[Host.UserMetrics.PanelCodes.service_worker_cache]);
     return false;
   }
 
@@ -192,6 +194,7 @@ export class BackForwardCacheTreeElement extends ApplicationPanelTreeElement {
       this.view = new ApplicationComponents.BackForwardCacheView.BackForwardCacheViewWrapper();
     }
     this.showView(this.view);
+    Host.userMetrics.panelShown(Host.UserMetrics.PanelCodes[Host.UserMetrics.PanelCodes.back_forward_cache]);
     return false;
   }
 }