[RPP] Rename ProfileNode functionName to originalFunctionName

Also removed some unused code in buildDetailsNodeForTraceEvent.

Bug: 456242397
Change-Id: Idc70296362be4abea68772dfbafeb564c370b82a
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/7098669
Auto-Submit: Connor Clark <[email protected]>
Reviewed-by: Paul Irish <[email protected]>
Commit-Queue: Connor Clark <[email protected]>

Author: Connor Clark

front_end/models/cpu_profile/ProfileTreeModel.ts

@@ -13,7 +13,7 @@ export class ProfileNode {
   id: number;
   parent: ProfileNode|null;
   children: this[];
-  functionName: string;
+  originalFunctionName: string|null = null;
   depth!: number;
   deoptReason!: string|null;
   constructor(callFrame: Protocol.Runtime.CallFrame) {
@@ -22,7 +22,6 @@ export class ProfileNode {
     this.self = 0;
     this.total = 0;
     this.id = 0;
-    this.functionName = callFrame.functionName;
     this.parent = null;
     this.children = [];
   }
@@ -43,11 +42,12 @@ export class ProfileNode {
     return this.callFrame.columnNumber;
   }
 
-  setFunctionName(name: string|null): void {
-    if (name === null) {
-      return;
-    }
-    this.functionName = name;
+  get functionName(): string {
+    return this.originalFunctionName ?? this.callFrame.functionName;
+  }
+
+  setOriginalFunctionName(name: string|null): void {
+    this.originalFunctionName = name;
   }
 }
 

front_end/models/trace/Name.test.ts

@@ -117,27 +117,21 @@ describeWithEnvironment('Name', () => {
     it('uses the profile name for a ProfileCall if it has been set', async function() {
       const parsedTrace = await TraceLoader.traceEngine(this, 'react-hello-world.json.gz');
       const {entry, profileNode} = getProfileEventAndNodeForReactTrace(parsedTrace);
-      // Store and then reset this: we are doing this to test the fallback to
-      // the entry callFrame.functionName property. After the assertion we
-      // reset this to avoid impacting other tests.
-      const originalProfileNodeName = profileNode.functionName;
-      profileNode.setFunctionName('testing-profile-name');
+      assert.isNull(profileNode.originalFunctionName);
+      profileNode.setOriginalFunctionName('testing-profile-name');
       const name = Trace.Name.forEntry(entry, parsedTrace);
       assert.strictEqual(name, 'testing-profile-name');
-      profileNode.setFunctionName(originalProfileNodeName);
+
+      // Don't impact other tests.
+      profileNode.setOriginalFunctionName(null);
     });
 
     it('falls back to the call frame name if a specific name has not been set', async function() {
       const parsedTrace = await TraceLoader.traceEngine(this, 'react-hello-world.json.gz');
       const {entry, profileNode} = getProfileEventAndNodeForReactTrace(parsedTrace);
-      // Store and then reset this: we are doing this to test the fallback to
-      // the entry callFrame.functionName property. After the assertion we
-      // reset this to avoid impacting other tests.
-      const originalProfileNodeName = profileNode.functionName;
-      profileNode.setFunctionName('');
+      assert.isNull(profileNode.originalFunctionName);
       const name = Trace.Name.forEntry(entry, parsedTrace);
       assert.strictEqual(name, 'performConcurrentWorkOnRoot');
-      profileNode.setFunctionName(originalProfileNodeName);
     });
 
     /** Finds a particular event from the react-hello-world trace which is used for our test example. **/

front_end/models/trace/handlers/SamplesHandler.test.ts

@@ -325,32 +325,25 @@ describeWithEnvironment('SamplesHandler', function() {
       };
     }
 
-    it('falls back to the call frame name if the ProfileNode name is empty', async function() {
+    it('falls back to the call frame name if the ProfileNode originalFunctionName is empty', async function() {
       const {data} = await TraceLoader.traceEngine(this, 'react-hello-world.json.gz');
       const {entry, profileNode} = getProfileEventAndNode(data);
-      // Store and then reset this: we are doing this to test the fallback to
-      // the entry callFrame.functionName property. After the assertion we
-      // reset this to avoid impacting other tests.
-      const originalProfileNodeName = profileNode.functionName;
-      profileNode.setFunctionName('');
+      assert.isNull(profileNode.originalFunctionName);
       assert.strictEqual(
           Trace.Handlers.ModelHandlers.Samples.getProfileCallFunctionName(data.Samples, entry),
           'performConcurrentWorkOnRoot');
-      // St
-      profileNode.setFunctionName(originalProfileNodeName);
     });
 
-    it('uses the profile name if it has been set', async function() {
+    it('uses the profile originalFunctionName if it has been set', async function() {
       const {data} = await TraceLoader.traceEngine(this, 'react-hello-world.json.gz');
       const {entry, profileNode} = getProfileEventAndNode(data);
-      // Store and then reset this: we are doing this to test the fallback to
-      // the entry callFrame.functionName property. After the assertion we
-      // reset this to avoid impacting other tests.
-      const originalProfileNodeName = profileNode.functionName;
-      profileNode.setFunctionName('testing-profile-name');
+      assert.isNull(profileNode.originalFunctionName);
+      profileNode.setOriginalFunctionName('testing-profile-name');
       assert.strictEqual(
           Trace.Handlers.ModelHandlers.Samples.getProfileCallFunctionName(data.Samples, entry), 'testing-profile-name');
-      profileNode.setFunctionName(originalProfileNodeName);
+
+      // Don't impact other tests.
+      profileNode.setOriginalFunctionName(null);
     });
   });
 });

front_end/models/trace_source_maps_resolver/SourceMapsResolver.ts

@@ -173,7 +173,7 @@ export class SourceMapsResolver extends EventTarget {
           const resolvedFunctionName =
               await SourceMapScopes.NamesResolver.resolveProfileFrameFunctionName(node.callFrame, target);
           updatedMappings ||= Boolean(resolvedFunctionName);
-          node.setFunctionName(resolvedFunctionName);
+          node.setOriginalFunctionName(resolvedFunctionName);
 
           const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
           const script = debuggerModel?.scriptForId(node.scriptId) || null;

front_end/panels/timeline/TimelineUIUtils.ts

@@ -732,26 +732,6 @@ export class TimelineUIUtils {
         break;
       }
 
-      case Trace.Types.Events.Name.COMPILE_SCRIPT:
-      case Trace.Types.Events.Name.CACHE_SCRIPT:
-      case Trace.Types.Events.Name.EVALUATE_SCRIPT: {
-        const url = unsafeEventData['url'];
-        if (url) {
-          const {lineNumber} = Trace.Helpers.Trace.getZeroIndexedLineAndColumnForEvent(event);
-          details = this.linkifyLocation({
-            scriptId: null,
-            url,
-            lineNumber: lineNumber || 0,
-            columnNumber: 0,
-            target,
-            isFreshOrEnhanced,
-            linkifier,
-            omitOrigin: true,
-          });
-        }
-        break;
-      }
-
       case Trace.Types.Events.Name.BACKGROUND_DESERIALIZE:
       case Trace.Types.Events.Name.STREAMING_COMPILE_SCRIPT: {
         const url = unsafeEventData['url'];
@@ -1710,6 +1690,7 @@ export class TimelineUIUtils {
     return {callFrames} as Protocol.Runtime.StackTrace;
   }
 
+  /** This renders a stack trace... and other cool stuff. */
   static async generateCauses(
       event: Trace.Types.Events.Event, contentHelper: TimelineDetailsContentHelper,
       parsedTrace: Trace.TraceModel.ParsedTrace): Promise<void> {
@@ -2478,6 +2459,9 @@ export class TimelineDetailsContentHelper {
     if (!this.#linkifier) {
       return;
     }
+
+    // We resolve the original function name here. StackTracePreviewContent uses
+    // Linkifier to resolve the source code location.
     const resolvedStackTrace: Protocol.Runtime.StackTrace = structuredClone(stackTrace);
     let currentResolvedStackTrace: Protocol.Runtime.StackTrace|undefined = resolvedStackTrace;
     while (currentResolvedStackTrace) {

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

@@ -255,10 +255,10 @@ describeWithEnvironment('ThreadAppender', function() {
     const anonymousCall = threadAppenders[0].titleForEvent(entry);
     assert.strictEqual(anonymousCall, '(anonymous)');
     const originalName = cpuProfileNode.functionName;
-    cpuProfileNode.setFunctionName('new-resolved-function-name');
+    cpuProfileNode.setOriginalFunctionName('new-resolved-function-name');
     assert.strictEqual(threadAppenders[0].titleForEvent(entry), 'new-resolved-function-name');
     // Reset the value for future tests.
-    cpuProfileNode.setFunctionName(originalName);
+    cpuProfileNode.setOriginalFunctionName(originalName);
   });
 
   function getDefaultInfo() {