RPP-AI: support origins in Performance AI assistance and auto-selection

This CL introduces the ability to calculate the origin for a given event
from the timeline that has been selected. The side-effect of this is now
as you click around the timeline on events, the AI Assistance panel will
update with the new event that you clicked on. Before this CL you had to
explicitly right click on an event to access the AI Assistance with the
selected event.

Some decisions that were made as part of this CL:

1. We calculate the origin from the non-resolved URL, which in this
   context means ignoring sourcemaps, and using the raw URL from the
   trace. This is on purpose because from a security perspective, we
   care about the URL it was served from, not if locally on the user's
   machine it was `node_modules/blah...`.
2. I take the origin from the _selected node_ in the call tree, not the
   root node. I could be argued on this, but most of the time the root
   node is something like a "Task" which does not have a URL assocated
   with it. But if you pick the "Evaluate Script" below it, that has a
   useful URL we can work with.
3. For events without a URL, we calculate a uuid which is unique and
   deterministic, thus ensuring that each event without a URL is treated
   as its own origin, so we don't mistakenly bucket up events without
   exact URLs into the same origin and risk any security concerns.
4. We decided not to cache the AICallTree creation. We find it unlikely
   that users will go back and forth on an event multiple times and the
   work isn't so expensive to be of concern.

Fixed: 390371494
Change-Id: Ib77a6c45cca7190e08f0ac4b2f5fe8e462c2ba3f
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6178276
Commit-Queue: Jack Franklin <[email protected]>
Reviewed-by: Alex Rudenko <[email protected]>
Reviewed-by: Paul Irish <[email protected]>

Author: jackfranklin

front_end/panels/ai_assistance/agents/PerformanceAgent.test.ts

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import * as Host from '../../../core/host/host.js';
+import * as Trace from '../../../models/trace/trace.js';
 import {describeWithEnvironment, getGetHostConfigStub} from '../../../testing/EnvironmentHelpers.js';
 import {TraceLoader} from '../../../testing/TraceLoader.js';
 import * as TimelineUtils from '../../timeline/utils/utils.js';
@@ -27,6 +28,30 @@ describeWithEnvironment('PerformanceAgent', () => {
     };
   }
 
+  describe('getOrigin()', () => {
+    it('calculates the origin of the selected node when it has a URL associated with it', async function() {
+      const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev-with-commit.json.gz');
+      // An Evaluate Script event, picked because it has a URL of googletagmanager.com/...
+      const evalScriptEvent = parsedTrace.Renderer.allTraceEntries.find(
+          event => event.name === Trace.Types.Events.Name.EVALUATE_SCRIPT && event.ts === 122411195649);
+      assert.exists(evalScriptEvent);
+      const aiCallTree = TimelineUtils.AICallTree.AICallTree.from(evalScriptEvent, parsedTrace);
+      const callTreeContext = new CallTreeContext(aiCallTree);
+      assert.strictEqual(callTreeContext.getOrigin(), 'https://www.googletagmanager.com');
+    });
+
+    it('returns a random but deterministic "origin" for nodes that have no URL associated', async function() {
+      const {parsedTrace} = await TraceLoader.traceEngine(this, 'web-dev-with-commit.json.gz');
+      // A random layout event with no URL associated
+      const layoutEvent = parsedTrace.Renderer.allTraceEntries.find(
+          event => event.name === Trace.Types.Events.Name.LAYOUT && event.ts === 122411130078);
+      assert.exists(layoutEvent);
+      const aiCallTree = TimelineUtils.AICallTree.AICallTree.from(layoutEvent, parsedTrace);
+      const callTreeContext = new CallTreeContext(aiCallTree);
+      assert.strictEqual(callTreeContext.getOrigin(), 'Layout_90829_259_122411130078');
+    });
+  });
+
   describe('buildRequest', () => {
     beforeEach(() => {
       sinon.restore();

front_end/panels/ai_assistance/agents/PerformanceAgent.ts

@@ -5,6 +5,7 @@
 import * as Common from '../../../core/common/common.js';
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
+import * as Trace from '../../../models/trace/trace.js';
 import * as TimelineUtils from '../../timeline/utils/utils.js';
 import * as PanelUtils from '../../utils/utils.js';
 
@@ -130,8 +131,25 @@ export class CallTreeContext extends ConversationContext<TimelineUtils.AICallTre
   }
 
   override getOrigin(): string {
-    // TODO: implement cross-origin checks for the PerformanceAgent.
-    return '';
+    const selectedEvent = this.#callTree.selectedNode.event;
+    // Get the non-resolved (ignore sourcemaps) URL for the event. We use the
+    // non-resolved URL as in the context of the AI Assistance panel, we care
+    // about the origin it was served on.
+    const nonResolvedURL = Trace.Handlers.Helpers.getNonResolvedURL(selectedEvent, this.#callTree.parsedTrace);
+    if (nonResolvedURL) {
+      const origin = Common.ParsedURL.ParsedURL.extractOrigin(nonResolvedURL);
+      if (origin) {  // origin could be the empty string.
+        return origin;
+      }
+    }
+    // Generate a random "origin". We do this rather than return an empty
+    // string or some "unknown" string so that each event without a definite
+    // URL is considered a new, standalone origin. This is safer from a privacy
+    // & security perspective, else we risk bucketing events together that
+    // should not be. We also don't want to make it entirely random so we
+    // cannot calculate it deterministically.
+    const uuid = `${selectedEvent.name}_${selectedEvent.pid}_${selectedEvent.tid}_${selectedEvent.ts}`;
+    return uuid;
   }
 
   override getItem(): TimelineUtils.AICallTree.AICallTree {

front_end/panels/timeline/TimelineFlameChartView.ts

@@ -1263,6 +1263,16 @@ export class TimelineFlameChartView extends Common.ObjectWrapper.eventMixin<Even
     this.mainFlameChart.setSelectedEntry(mainIndex);
     this.networkFlameChart.setSelectedEntry(networkIndex);
 
+    // Set the context's "flavor" to be the AI Call Tree of the active event.
+    // This is listened to by the AI Assistance panel.
+    if (selectionIsEvent(selection) && this.#parsedTrace) {
+      // TODO: should we cache this?
+      const aiCallTree = Utils.AICallTree.AICallTree.from(selection.event, this.#parsedTrace);
+      UI.Context.Context.instance().setFlavor(Utils.AICallTree.AICallTree, aiCallTree);
+    } else {
+      UI.Context.Context.instance().setFlavor(Utils.AICallTree.AICallTree, null);
+    }
+
     // Clear any existing entry selection.
     this.#overlays.removeOverlaysOfType('ENTRY_SELECTED');
     // If: