[RPP Icicle blowtorch] Update the name of ignored script

Also including the matched rule in the name so it can be more informative.

Screenshots: https://screenshot.googleplex.com/6wQH3mVctUp6bjx
Bug:376657746
Change-Id: I403b17f277179ad968bfd8210d457636f8a46df5
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/5987912
Commit-Queue: Nancy Li <[email protected]>
Reviewed-by: Paul Irish <[email protected]>

Author: Nancy Li

front_end/models/bindings/IgnoreListManager.ts

@@ -219,12 +219,35 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
     if (this.#isIgnoreListedURLCache.has(url)) {
       return Boolean(this.#isIgnoreListedURLCache.get(url));
     }
-    const regex = this.getSkipStackFramesPatternSetting().asRegExp();
-    const isIgnoreListed = (regex && regex.test(url)) || false;
+
+    const isIgnoreListed = this.getFirstMatchedRegex(url) !== null;
     this.#isIgnoreListedURLCache.set(url, isIgnoreListed);
     return isIgnoreListed;
   }
 
+  getFirstMatchedRegex(url: Platform.DevToolsPath.UrlString): RegExp|null {
+    if (!url) {
+      return null;
+    }
+    const regexPatterns = this.getSkipStackFramesPatternSetting().getAsArray();
+    const regexValue = this.urlToRegExpString(url);
+    if (!regexValue) {
+      return null;
+    }
+
+    for (let i = 0; i < regexPatterns.length; ++i) {
+      const item = regexPatterns[i];
+      if (item.disabled || item.disabledForUrl === url) {
+        continue;
+      }
+      const regex = new RegExp(item.pattern);
+      if (regex.test(url)) {
+        return regex;
+      }
+    }
+    return null;
+  }
+
   private sourceMapAttached(
       event: Common.EventTarget.EventTargetEvent<{client: SDK.Script.Script, sourceMap: SDK.SourceMap.SourceMap}>):
       void {

front_end/panels/timeline/ThreadAppender.ts

@@ -29,10 +29,11 @@ import * as Utils from './utils/utils.js';
 
 const UIStrings = {
   /**
-   *@description Text shown for an entry in the flame chart that is ignored because it matches
+   * @description Text shown for an entry in the flame chart that is ignored because it matches
    * a predefined ignore list.
+   * @example {/analytics\.js$} rule
    */
-  onIgnoreList: 'On ignore list',
+  onIgnoreList: 'On ignore list ({rule})',
   /**
    * @description Refers to the "Main frame", meaning the top level frame. See https://www.w3.org/TR/html401/present/frames.html
    * @example{example.com} PH1
@@ -571,7 +572,8 @@ export class ThreadAppender implements TrackAppender {
    */
   titleForEvent(entry: Trace.Types.Events.Event): string {
     if (Utils.IgnoreList.isIgnoreListedEntry(entry)) {
-      return i18nString(UIStrings.onIgnoreList);
+      const rule = Utils.IgnoreList.getIgnoredReasonString(entry);
+      return i18nString(UIStrings.onIgnoreList, {rule});
     }
     return Utils.EntryName.nameForEntry(entry, this.#parsedTrace);
   }

front_end/panels/timeline/track_appenders/ThreadAppender.test.ts

@@ -481,7 +481,7 @@ describeWithEnvironment('ThreadAppender', function() {
       assert.deepEqual(flameChartData.entryStartTimes, [0.1, 0.1, 0.1, 0.2]);
       assert.deepEqual(flameChartData.entryTotalTimes, [0.2, 0.1, 0.025, 0.1]);
       assert.strictEqual(threadAppenders.length, 1);
-      assert.strictEqual(threadAppenders[0].titleForEvent(callFrameB), 'On ignore list');
+      assert.strictEqual(threadAppenders[0].titleForEvent(callFrameB), 'On ignore list (\\\/bundled\\.js$)');
     });
   });
   describe('showAllEvents', () => {

front_end/panels/timeline/utils/IgnoreList.test.ts

@@ -4,8 +4,10 @@
 
 import * as Common from '../../../core/common/common.js';
 import type * as Platform from '../../../core/platform/platform.js';
+import * as SDK from '../../../core/sdk/sdk.js';
 import * as Bindings from '../../../models/bindings/bindings.js';
 import * as Trace from '../../../models/trace/trace.js';
+import * as Workspace from '../../../models/workspace/workspace.js';
 import {
   describeWithMockConnection,
 } from '../../../testing/MockConnection.js';
@@ -89,6 +91,8 @@ describeWithMockConnection('isIgnoreListedEntry', () => {
 
        ignoreKnownThirdPartySetting.set(true);
        assert.isTrue(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithMappings));
+       assert.strictEqual(
+           'Marked with ignoreList in source map', Utils.IgnoreList.getIgnoredReasonString(profileCallWithMappings));
 
        ignoreKnownThirdPartySetting.set(false);
        assert.isFalse(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithMappings));
@@ -130,11 +134,59 @@ describeWithMockConnection('isIgnoreListedEntry', () => {
 
     ignoreContentScriptSetting.set(true);
     assert.isTrue(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithContentScript));
+    assert.strictEqual('Content script', Utils.IgnoreList.getIgnoredReasonString(profileCallWithContentScript));
 
     ignoreContentScriptSetting.set(false);
     assert.isFalse(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithContentScript));
 
     // restore to the original value.
     ignoreContentScriptSetting.set(ignoreContentScriptSettingValue);
   });
+
+  it('get the first matched rule for the ignored script', async () => {
+    const targetManager = SDK.TargetManager.TargetManager.instance();
+    const workspace = Workspace.Workspace.WorkspaceImpl.instance({forceNew: true});
+    const resourceMapping = new Bindings.ResourceMapping.ResourceMapping(targetManager, workspace);
+    const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance(
+        {forceNew: true, resourceMapping, targetManager});
+    Bindings.IgnoreListManager.IgnoreListManager.instance({
+      forceNew: true,
+      debuggerWorkspaceBinding,
+    });
+    ignoreRegex('youtube*');
+    const url = 'https://www.youtube.com/s/desktop/2ebf714b/jsbin/desktop_polymer.vflset/desktop_polymer.js' as
+        Platform.DevToolsPath.UrlString;
+    Bindings.IgnoreListManager.IgnoreListManager.instance().ignoreListURL(url);
+
+    const entry = makeProfileCall(
+        'function name', 10, 100, Trace.Types.Events.ProcessID(1), Trace.Types.Events.ThreadID(1), /* nodeId= */ 1,
+        url);
+    // There are two matched rules (in order)
+    // - youtube*
+    // - \\/desktop_polymer\\.js$ (generated by the URL)
+    // So the first matched one is `youtube*`
+    assert.strictEqual('youtube*', Utils.IgnoreList.getIgnoredReasonString(entry));
+
+    unignoreRegex('youtube*');
+    // Now There is only one matched rule.
+    assert.strictEqual('\\/desktop_polymer\\.js$', Utils.IgnoreList.getIgnoredReasonString(entry));
+  });
 });
+
+function ignoreRegex(regexValue: string): void {
+  const regexPatterns =
+      (Common.Settings.Settings.instance().moduleSetting('skip-stack-frames-pattern') as Common.Settings.RegExpSetting)
+          .getAsArray();
+  regexPatterns.push({pattern: regexValue, disabled: false});
+}
+
+function unignoreRegex(regexValue: string): void {
+  const regexPatterns =
+      (Common.Settings.Settings.instance().moduleSetting('skip-stack-frames-pattern') as Common.Settings.RegExpSetting)
+          .getAsArray();
+  const result =
+      regexPatterns.filter(regexPattern => regexPattern.pattern !== regexValue) as Common.Settings.RegExpSettingItem[];
+
+  (Common.Settings.Settings.instance().moduleSetting('skip-stack-frames-pattern') as Common.Settings.RegExpSetting)
+      .setAsArray(result);
+}

front_end/panels/timeline/utils/IgnoreList.ts

@@ -2,16 +2,37 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as i18n from '../../../core/i18n/i18n.js';
 import type * as Platform from '../../../core/platform/platform.js';
 import * as Bindings from '../../../models/bindings/bindings.js';
 import * as Trace from '../../../models/trace/trace.js';
 
 import {SourceMapsResolver} from './SourceMapsResolver.js';
 
-export function isIgnoreListedEntry(entry: Trace.Types.Events.Event): boolean {
-  if (!Trace.Types.Events.isProfileCall(entry)) {
-    return false;
-  }
+const UIStrings = {
+  /**
+   * @description Refers to when skipping content scripts is enabled and the current script is ignored because it's a content script.
+   */
+  skipContentScripts: 'Content script',
+  /**
+   * @description Refers to when skipping known third party scripts is enabled and the current script is ignored because it's a known third party script.
+   */
+  skip3rdPartyScripts: 'Marked with ignoreList in source map',
+  /**
+   * @description Refers to when skipping anonymous scripts is enabled and the current script is ignored because is an anonymous script.
+   */
+  skipAnonymousScripts: 'Anonymous script',
+  /**
+   * @description Refers to when the current script is ignored because of an unknown rule.
+   */
+  unknown: 'Unknown',
+};
+
+const str_ = i18n.i18n.registerUIStrings('panels/timeline/utils/IgnoreList.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+
+function getUrlAndIgnoreListOptions(entry: Trace.Types.Events.SyntheticProfileCall):
+    {url: Platform.DevToolsPath.UrlString, ignoreListOptions: Bindings.IgnoreListManager.IgnoreListGeneralRules} {
   const rawUrl = entry.callFrame.url as Platform.DevToolsPath.UrlString;
 
   const sourceMappedData = SourceMapsResolver.resolvedCodeLocationForEntry(entry);
@@ -21,11 +42,51 @@ export function isIgnoreListedEntry(entry: Trace.Types.Events.Event): boolean {
   const isKnownThirdParty = uiSourceCode?.isKnownThirdParty();
   const isContentScript = script?.isContentScript();
   const ignoreListOptions: Bindings.IgnoreListManager.IgnoreListGeneralRules = {isContentScript, isKnownThirdParty};
-  const urlToUse = resolvedUrl || rawUrl;
-  return isIgnoreListedURL(urlToUse, ignoreListOptions);
+  const url = resolvedUrl || rawUrl;
+  return {url, ignoreListOptions};
 }
 
-export function isIgnoreListedURL(
+export function isIgnoreListedEntry(entry: Trace.Types.Events.Event): boolean {
+  if (!Trace.Types.Events.isProfileCall(entry)) {
+    return false;
+  }
+  const {url, ignoreListOptions} = getUrlAndIgnoreListOptions(entry);
+  return isIgnoreListedURL(url, ignoreListOptions);
+}
+
+function isIgnoreListedURL(
     url: Platform.DevToolsPath.UrlString, options?: Bindings.IgnoreListManager.IgnoreListGeneralRules): boolean {
   return Bindings.IgnoreListManager.IgnoreListManager.instance().isUserIgnoreListedURL(url, options);
 }
+
+/**
+ * Returns the ignore reason for the given entry.
+ *
+ * This function should be called when `isIgnoreListedEntry(entry)` is true
+ */
+export function getIgnoredReasonString(entry: Trace.Types.Events.Event): string {
+  if (!Trace.Types.Events.isProfileCall(entry)) {
+    console.warn('Ignore list feature should only support ProfileCall.');
+    return '';
+  }
+  const {url, ignoreListOptions} = getUrlAndIgnoreListOptions(entry);
+
+  const ignoreListMgr = Bindings.IgnoreListManager.IgnoreListManager.instance();
+  if (ignoreListOptions.isContentScript && ignoreListMgr.skipContentScripts) {
+    return i18nString(UIStrings.skipContentScripts);
+  }
+  if (ignoreListOptions.isKnownThirdParty && ignoreListMgr.automaticallyIgnoreListKnownThirdPartyScripts) {
+    return i18nString(UIStrings.skip3rdPartyScripts);
+  }
+
+  if (!url) {
+    if (ignoreListMgr.skipAnonymousScripts) {
+      return i18nString(UIStrings.skipAnonymousScripts);
+    }
+    // This branch shouldn't be reached because when |skipAnonymousScripts| is false, this url is not ignored.
+    // So just return empty string to make the type check work.
+    return '';
+  }
+  const regex = ignoreListMgr.getFirstMatchedRegex(url);
+  return regex ? regex.source : i18nString(UIStrings.unknown);
+}