Excluding extension content and sourcemap from exported trace.

This CL excludes script content and sourcemaps from chrome-extension and
 extension URLs when exporting a trace. Including this data does not
enhance the debugging experience and, due to privacy concerns, its
removal helps reduce both the complexity and size of the trace. Note
that events from these sources will still be captured and displayed
during regular trace session. The exclusion only applies when the trace
is exported.

For testing I'm adding a new trace that contains scripts for
'chrome-extensions' both in the sourcemap and souceText(per trace)
section.

Bug: 432046665
Change-Id: I5fd1c3df65dd66921f17ab11bb5e274217d2ea3a
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6866821
Reviewed-by: Connor Clark <[email protected]>
Commit-Queue: Vidal Diazleal <[email protected]>

Author: vidorteg

front_end/models/trace/helpers/Trace.ts

@@ -527,6 +527,10 @@ export function isTopLevelEvent(event: Types.Events.Event): boolean {
   return event.cat.includes(DevToolsTimelineEventCategory) && event.name === Types.Events.Name.RUN_TASK;
 }
 
+export function isExtensionUrl(url: string): boolean {
+  return url.startsWith('extensions:') || url.startsWith('chrome-extension:');
+}
+
 function topLevelEventIndexEndingAfter(events: Types.Events.Event[], time: Types.Timing.Micro): number {
   let index = Platform.ArrayUtilities.upperBound(events, time, (time, event) => time - event.ts) - 1;
   while (index > 0 && !isTopLevelEvent(events[index])) {

front_end/models/trace/types/File.ts

@@ -219,7 +219,7 @@ export interface MetaData {
   hostDPR?: number;
 }
 
-interface MetadataSourceMap {
+export interface MetadataSourceMap {
   url: string;
   /** If not defined, then this was a data url. */
   sourceMapUrl?: string;

front_end/panels/timeline/TimelinePanel.test.ts

@@ -446,5 +446,93 @@ describeWithEnvironment('TimelinePanel', function() {
         assert.deepEqual(file.traceEvents, traceEvents);
       });
     });
+
+    describe('removes chrome-extensions content', function() {
+      it('from trace events when saving a trace with "Include script content" on', async function() {
+        const {traceEvents, metadata} =
+            await TraceLoader.traceFile(this, 'chrome-ext-sourcemap-script-content.json.gz');
+        await timeline.loadingComplete(traceEvents as Trace.Types.Events.Event[], null, metadata);
+
+        // 7192505913775043000.8 matches a chrome-extension script in the trace
+        let extensionTracesWithContent = traceEvents.filter(value => {
+          return value.cat === 'disabled-by-default-devtools.v8-source-rundown-sources' &&
+              `${(value as Trace.Types.Events.V8SourceRundownSourcesScriptCatchupEvent).args.data.isolate}.${
+                  (value as Trace.Types.Events.V8SourceRundownSourcesScriptCatchupEvent).args.data.scriptId}` ===
+              '7192505913775043000.8';
+        });
+
+        // loading the trace and verifying the chrome extension script has associated source text
+        let castedEvent =
+            (extensionTracesWithContent[0] as Trace.Types.Events.V8SourceRundownSourcesScriptCatchupEvent);
+        assert.lengthOf(extensionTracesWithContent, 1);
+        assert.isDefined(castedEvent.args.data.sourceText);
+
+        await timeline.saveToFile({
+          includeScriptContent: true,
+          includeSourceMaps: false,
+          addModifications: false,
+        });
+
+        sinon.assert.calledOnce(saveSpy);
+        sinon.assert.calledOnce(closeSpy);
+
+        const [fileName, contentData] = saveSpy.getCall(0).args;
+        assert.match(fileName, /EnhancedTrace-[\d|T]+\.json$/);
+
+        const file = await contentDataToFile(contentData);
+        assert.isDefined(file.metadata.enhancedTraceVersion);
+
+        // getting the same trace as before, but this time after saving has happened.
+        extensionTracesWithContent = file.traceEvents?.filter(value => {
+          return value.cat === 'disabled-by-default-devtools.v8-source-rundown-sources' &&
+              `${(value as Trace.Types.Events.V8SourceRundownSourcesScriptCatchupEvent).args.data.isolate}.${
+                  (value as Trace.Types.Events.V8SourceRundownSourcesScriptCatchupEvent).args.data.scriptId}` ===
+              '7192505913775043000.8';
+        });
+
+        // the associated source text is now undefined from the chrome-extension script
+        castedEvent = (extensionTracesWithContent[0] as Trace.Types.Events.V8SourceRundownSourcesScriptCatchupEvent);
+        assert.lengthOf(extensionTracesWithContent, 1);
+        assert.isUndefined(castedEvent.args.data.sourceText);
+
+        // non-extension script content is still present (7192505913775043000.10)
+        extensionTracesWithContent = file.traceEvents?.filter(value => {
+          return value.cat === 'disabled-by-default-devtools.v8-source-rundown-sources' &&
+              `${(value as Trace.Types.Events.V8SourceRundownSourcesScriptCatchupEvent).args.data.isolate}.${
+                  (value as Trace.Types.Events.V8SourceRundownSourcesScriptCatchupEvent).args.data.scriptId}` ===
+              '7192505913775043000.10';
+        });
+        castedEvent = (extensionTracesWithContent[0] as Trace.Types.Events.V8SourceRundownSourcesScriptCatchupEvent);
+        assert.lengthOf(extensionTracesWithContent, 1);
+        assert.isDefined(castedEvent.args.data.sourceText);
+      });
+
+      it('from trace sourcemaps when saving a trace with "Include source map" on', async function() {
+        const {traceEvents, metadata} =
+            await TraceLoader.traceFile(this, 'chrome-ext-sourcemap-script-content.json.gz');
+
+        await timeline.innerSaveToFile(traceEvents, metadata, {
+          includeScriptContent: true,
+          includeSourceMaps: true,
+          addModifications: false,
+        });
+
+        sinon.assert.calledOnce(saveSpy);
+        sinon.assert.calledOnce(closeSpy);
+
+        const [fileName, contentData] = saveSpy.getCall(0).args;
+        assert.match(fileName, /EnhancedTrace-[\d|T]+\.json$/);
+
+        const file = await contentDataToFile(contentData);
+        assert.isDefined(file.metadata.enhancedTraceVersion);
+
+        const totalSourceMapsWithChromExtensionProtocol = file.metadata.sourceMaps?.filter(value => {
+          value.url.startsWith('chrome-extension:');
+        });
+        assert.isNotNull(totalSourceMapsWithChromExtensionProtocol);
+        assert.strictEqual(totalSourceMapsWithChromExtensionProtocol?.length, 0);
+      });
+    });
+
   });
 });

front_end/panels/timeline/TimelinePanel.ts

@@ -1407,11 +1407,24 @@ export class TimelinePanel extends Common.ObjectWrapper.eventMixin<EventTypes, t
       return;
     }
 
+    // Grab the script mapping to be able to filter out by url.
+    const mappedScriptsWithData = Trace.Handlers.ModelHandlers.Scripts.data().scripts;
+    const scriptByIdMap = new Map<string, Trace.Handlers.ModelHandlers.Scripts.Script>();
+
+    for (const mapScript of mappedScriptsWithData) {
+      scriptByIdMap.set(`${mapScript.isolate}.${mapScript.scriptId}`, mapScript);
+    }
+
     const metadata = this.#traceEngineModel.metadata(this.#viewMode.traceIndex) ?? {};
 
-    if (!config.includeScriptContent) {
-      traceEvents = traceEvents.map(event => {
-        if (Trace.Types.Events.isAnyScriptCatchupEvent(event) && event.name !== 'StubScriptCatchup') {
+    traceEvents = traceEvents.map(event => {
+      if (Trace.Types.Events.isAnyScriptCatchupEvent(event) && event.name !== 'StubScriptCatchup') {
+        const mappedScript = scriptByIdMap.get(`${event.args.data.isolate}.${event.args.data.scriptId}`);
+
+        // If the checkbox to include script content is not checked or if it comes from and
+        // extension we dont include the script content.
+        if (!config.includeScriptContent ||
+            (mappedScript?.url && Trace.Helpers.Trace.isExtensionUrl(mappedScript.url))) {
           return {
             cat: event.cat,
             name: 'StubScriptCatchup',
@@ -1425,10 +1438,10 @@ export class TimelinePanel extends Common.ObjectWrapper.eventMixin<EventTypes, t
             },
           } as Trace.Types.Events.V8SourceRundownSourcesStubScriptCatchupEvent;
         }
+      }
 
-        return event;
-      });
-    }
+      return event;
+    });
 
     metadata.modifications = config.addModifications ? ModificationsManager.activeManager()?.toJSON() : undefined;
 
@@ -1483,9 +1496,11 @@ export class TimelinePanel extends Common.ObjectWrapper.eventMixin<EventTypes, t
       const profile = Trace.Helpers.SamplesIntegrator.SamplesIntegrator.extractCpuProfileFromFakeTrace(traceEvents);
       blobParts = [JSON.stringify(profile)];
     } else {
+      const filteredMetadataSourceMaps =
+          includeScriptContent && includeSourceMaps ? this.#filterMetadataSourceMaps(metadata) : undefined;
       const formattedTraceIter = traceJsonGenerator(traceEvents, {
         ...metadata,
-        sourceMaps: includeScriptContent && includeSourceMaps ? metadata.sourceMaps : undefined,
+        sourceMaps: filteredMetadataSourceMaps,
       });
       blobParts = Array.from(formattedTraceIter);
     }
@@ -1532,6 +1547,18 @@ export class TimelinePanel extends Common.ObjectWrapper.eventMixin<EventTypes, t
     }
   }
 
+  #filterMetadataSourceMaps(metadata: Trace.Types.File.MetaData): Trace.Types.File.MetadataSourceMap[]|undefined {
+    if (!metadata.sourceMaps) {
+      return undefined;
+    }
+
+    // extensions sourcemaps provide little to no-value for the exported trace
+    // debugging, so they are filtered out.
+    return metadata.sourceMaps.filter(value => {
+      return value.url && Trace.Helpers.Trace.isExtensionUrl(value.url);
+    });
+  }
+
   #showExportTraceErrorDialog(error: Error): void {
     if (this.statusDialog) {
       this.statusDialog.remove();

front_end/panels/timeline/fixtures/traces/BUILD.gn

@@ -15,6 +15,7 @@ copy_to_gen("traces") {
     "basic.json.gz",
     "byte-efficiency.json.gz",
     "changing-priority.json.gz",
+    "chrome-ext-sourcemap-script-content.json.gz",
     "cls-cluster-max-duration.json.gz",
     "cls-cluster-max-timeout.json.gz",
     "cls-cluster-navigation.json.gz",

front_end/panels/timeline/fixtures/traces/README.md

@@ -48,6 +48,14 @@ A very barebones trace; contains info on browser processes and threads but very
 
 A recording of a page load of the Lighthouse byte-efficiency tester. https://github.com/GoogleChrome/lighthouse/blob/main/cli/test/fixtures/byte-efficiency/tester.html
 
+### chrome-ext-sourcemap-script-content.json.gz
+
+Trace generated after installing https://chromewebstore.google.com/detail/react-developer-tools/. A regular trace that contains two sections
+not found in other traces:
+
+1. A sourcemap in the metadata array with a 'chrome-extension' protocol.
+2. 'V8SourceRundownSourcesScriptCatchupEvent' traces that have a 'chrome-extension' protocol with associated source text.
+
 ### dom-size.json.gz
 
 Generate from a recording of [this HTML file](https://gist.github.com/adamraine/bfdb3cecca2322bf74f1e725d9a4699d) with the following steps: