@paulirish/trace_engine 0.0.10 → 0.0.12

package/models/trace/handlers/ScreenshotsHandler.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../front_end/models/trace/handlers/ScreenshotsHandler.ts"],
-  "sourcesContent": ["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Helpers from '../helpers/helpers.js';\nimport * as Types from '../types/types.js';\n\nimport {type TraceEventHandlerName} from './types.js';\n\n// Each thread contains events. Events indicate the thread and process IDs, which are\n// used to store the event in the correct process thread entry below.\nconst unpairedAsyncEvents: Types.TraceEvents.TraceEventPipelineReporter[] = [];\n\nconst snapshotEvents: Types.TraceEvents.TraceEventScreenshot[] = [];\nconst syntheticScreenshotEvents: Types.TraceEvents.SyntheticScreenshot[] = [];\nlet frameSequenceToTs: Record<string, Types.Timing.MicroSeconds> = {};\n\nexport function reset(): void {\n  unpairedAsyncEvents.length = 0;\n  snapshotEvents.length = 0;\n  syntheticScreenshotEvents.length = 0;\n  frameSequenceToTs = {};\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  if (Types.TraceEvents.isTraceEventScreenshot(event)) {\n    snapshotEvents.push(event);\n  } else if (Types.TraceEvents.isTraceEventPipelineReporter(event)) {\n    unpairedAsyncEvents.push(event);\n  }\n}\n\nexport async function finalize(): Promise<void> {\n  const pipelineReporterEvents = Helpers.Trace.createMatchedSortedSyntheticEvents(unpairedAsyncEvents);\n\n  frameSequenceToTs = Object.fromEntries(pipelineReporterEvents.map(evt => {\n    const frameSequenceId = evt.args.data.beginEvent.args.chrome_frame_reporter.frame_sequence;\n    const presentationTs = Types.Timing.MicroSeconds(evt.ts + evt.dur);\n    return [frameSequenceId, presentationTs];\n  }));\n\n  for (const snapshotEvent of snapshotEvents) {\n    const {cat, name, ph, pid, tid} = snapshotEvent;\n    const syntheticEvent: Types.TraceEvents.SyntheticScreenshot = {\n      cat,\n      name,\n      ph,\n      pid,\n      tid,\n      // `getPresentationTimestamp(snapshotEvent) - snapshotEvent.ts` is how many microsec the screenshot was adjusted to the right/later\n      ts: getPresentationTimestamp(snapshotEvent),\n      args: {\n        dataUri: `data:image/jpg;base64,${snapshotEvent.args.snapshot}`,\n      },\n    };\n    syntheticScreenshotEvents.push(syntheticEvent);\n  }\n}\n\n/**\n * Correct the screenshot timestamps\n * The screenshot 'snapshot object' trace event has the \"frame sequence number\" attached as an ID.\n * We match that up with the \"PipelineReporter\" trace events as they terminate at presentation.\n * Presentation == when the pixels hit the screen. AKA Swap on the GPU\n */\nfunction getPresentationTimestamp(screenshotEvent: Types.TraceEvents.TraceEventScreenshot): Types.Timing.MicroSeconds {\n  const frameSequence = parseInt(screenshotEvent.id, 16);\n  // If it's 1, then it's an old trace (before https://crrev.com/c/4957973) and cannot be corrected.\n  if (frameSequence === 1) {\n    return screenshotEvent.ts;\n  }\n  // The screenshot trace event's `ts` reflects the \"expected display time\" which is ESTIMATE.\n  // It is set by the compositor frame sink from the `expected_display_time`, which is based on a previously known\n  // frame start PLUS the vsync interval (eg 16.6ms)\n  const updatedTs = frameSequenceToTs[frameSequence];\n  // Do we always find a match? No...\n  // We generally don't match the very first screenshot and, sometimes, the last\n  // The very first screenshot is requested immediately (even if nothing is painting). As a result there's no compositor\n  // instrumentation running alongside.\n  // The last one is sometimes missing as because the trace terminates right before the associated PipelineReporter is emitted.\n  return updatedTs ?? screenshotEvent.ts;\n}\n\nexport function data(): Types.TraceEvents.SyntheticScreenshot[] {\n  return [...syntheticScreenshotEvents];\n}\n\nexport function deps(): TraceEventHandlerName[] {\n  return ['Meta'];\n}\n"],
-  "mappings": "AAIA;AACA;AAMA,MAAM,sBAAsE;AAE5E,MAAM,iBAA2D;AACjE,MAAM,4BAAqE;AAC3E,IAAI,oBAA+D;AAE5D,wBAAuB;AAC5B,sBAAoB,SAAS;AAC7B,iBAAe,SAAS;AACxB,4BAA0B,SAAS;AACnC,sBAAoB;AAAA;AAGf,4BAAqB,OAA+C;AACzE,MAAI,MAAM,YAAY,uBAAuB,QAAQ;AACnD,mBAAe,KAAK;AAAA,aACX,MAAM,YAAY,6BAA6B,QAAQ;AAChE,wBAAoB,KAAK;AAAA;AAAA;AAI7B,iCAAgD;AAC9C,QAAM,yBAAyB,QAAQ,MAAM,mCAAmC;AAEhF,sBAAoB,OAAO,YAAY,uBAAuB,IAAI,SAAO;AACvE,UAAM,kBAAkB,IAAI,KAAK,KAAK,WAAW,KAAK,sBAAsB;AAC5E,UAAM,iBAAiB,MAAM,OAAO,aAAa,IAAI,KAAK,IAAI;AAC9D,WAAO,CAAC,iBAAiB;AAAA;AAG3B,aAAW,iBAAiB,gBAAgB;AAC1C,UAAM,EAAC,KAAK,MAAM,IAAI,KAAK,QAAO;AAClC,UAAM,iBAAwD;AAAA,MAC5D;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MAEA,IAAI,yBAAyB;AAAA,MAC7B,MAAM;AAAA,QACJ,SAAS,yBAAyB,cAAc,KAAK;AAAA;AAAA;AAGzD,8BAA0B,KAAK;AAAA;AAAA;AAUnC,kCAAkC,iBAAoF;AACpH,QAAM,gBAAgB,SAAS,gBAAgB,IAAI;AAEnD,MAAI,kBAAkB,GAAG;AACvB,WAAO,gBAAgB;AAAA;AAKzB,QAAM,YAAY,kBAAkB;AAMpC,SAAO,aAAa,gBAAgB;AAAA;AAG/B,uBAAyD;AAC9D,SAAO,CAAC,GAAG;AAAA;AAGN,uBAAyC;AAC9C,SAAO,CAAC;AAAA;",
-  "names": []
-}
+{"version":3,"file":"ScreenshotsHandler.js","sourceRoot":"","sources":["../../../../../../../front_end/models/trace/handlers/ScreenshotsHandler.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,yEAAyE;AACzE,6BAA6B;AAE7B,OAAO,KAAK,OAAO,MAAM,uBAAuB,CAAC;AACjD,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAI3C,qFAAqF;AACrF,qEAAqE;AACrE,MAAM,mBAAmB,GAAmD,EAAE,CAAC;AAE/E,MAAM,cAAc,GAA6C,EAAE,CAAC;AACpE,MAAM,yBAAyB,GAA4C,EAAE,CAAC;AAC9E,IAAI,iBAAiB,GAA8C,EAAE,CAAC;AAEtE,MAAM,UAAU,KAAK;IACnB,mBAAmB,CAAC,MAAM,GAAG,CAAC,CAAC;IAC/B,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC;IAC1B,yBAAyB,CAAC,MAAM,GAAG,CAAC,CAAC;IACrC,iBAAiB,GAAG,EAAE,CAAC;AACzB,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,KAAuC;IACjE,IAAI,KAAK,CAAC,WAAW,CAAC,sBAAsB,CAAC,KAAK,CAAC,EAAE;QACnD,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;KAC5B;SAAM,IAAI,KAAK,CAAC,WAAW,CAAC,4BAA4B,CAAC,KAAK,CAAC,EAAE;QAChE,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;KACjC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,QAAQ;IAC5B,MAAM,sBAAsB,GAAG,OAAO,CAAC,KAAK,CAAC,kCAAkC,CAAC,mBAAmB,CAAC,CAAC;IAErG,iBAAiB,GAAG,MAAM,CAAC,WAAW,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;QACtE,MAAM,eAAe,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAC;QAC3F,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;QACnE,OAAO,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC,CAAC;IAEJ,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE;QAC1C,MAAM,EAAC,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAC,GAAG,aAAa,CAAC;QAChD,MAAM,cAAc,GAA0C;YAC5D,GAAG;YACH,IAAI;YACJ,EAAE;YACF,GAAG;YACH,GAAG;YACH,mIAAmI;YACnI,EAAE,EAAE,wBAAwB,CAAC,aAAa,CAAC;YAC3C,IAAI,EAAE;gBACJ,OAAO,EAAE,yBAAyB,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE;aAChE;SACF,CAAC;QACF,yBAAyB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;KAChD;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,wBAAwB,CAAC,eAAuD;IACvF,MAAM,aAAa,GAAG,QAAQ,CAAC,eAAe,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IACvD,kGAAkG;IAClG,IAAI,aAAa,KAAK,CAAC,EAAE;QACvB,OAAO,eAAe,CAAC,EAAE,CAAC;KAC3B;IACD,4FAA4F;IAC5F,gHAAgH;IAChH,kDAAkD;IAClD,MAAM,SAAS,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAC;IACnD,mCAAmC;IACnC,8EAA8E;IAC9E,sHAAsH;IACtH,qCAAqC;IACrC,6HAA6H;IAC7H,OAAO,SAAS,IAAI,eAAe,CAAC,EAAE,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,IAAI;IAClB,OAAO,CAAC,GAAG,yBAAyB,CAAC,CAAC;AACxC,CAAC;AAED,MAAM,UAAU,IAAI;IAClB,OAAO,CAAC,MAAM,CAAC,CAAC;AAClB,CAAC","sourcesContent":["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Helpers from '../helpers/helpers.js';\nimport * as Types from '../types/types.js';\n\nimport {type TraceEventHandlerName} from './types.js';\n\n// Each thread contains events. Events indicate the thread and process IDs, which are\n// used to store the event in the correct process thread entry below.\nconst unpairedAsyncEvents: Types.TraceEvents.TraceEventPipelineReporter[] = [];\n\nconst snapshotEvents: Types.TraceEvents.TraceEventScreenshot[] = [];\nconst syntheticScreenshotEvents: Types.TraceEvents.SyntheticScreenshot[] = [];\nlet frameSequenceToTs: Record<string, Types.Timing.MicroSeconds> = {};\n\nexport function reset(): void {\n  unpairedAsyncEvents.length = 0;\n  snapshotEvents.length = 0;\n  syntheticScreenshotEvents.length = 0;\n  frameSequenceToTs = {};\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  if (Types.TraceEvents.isTraceEventScreenshot(event)) {\n    snapshotEvents.push(event);\n  } else if (Types.TraceEvents.isTraceEventPipelineReporter(event)) {\n    unpairedAsyncEvents.push(event);\n  }\n}\n\nexport async function finalize(): Promise<void> {\n  const pipelineReporterEvents = Helpers.Trace.createMatchedSortedSyntheticEvents(unpairedAsyncEvents);\n\n  frameSequenceToTs = Object.fromEntries(pipelineReporterEvents.map(evt => {\n    const frameSequenceId = evt.args.data.beginEvent.args.chrome_frame_reporter.frame_sequence;\n    const presentationTs = Types.Timing.MicroSeconds(evt.ts + evt.dur);\n    return [frameSequenceId, presentationTs];\n  }));\n\n  for (const snapshotEvent of snapshotEvents) {\n    const {cat, name, ph, pid, tid} = snapshotEvent;\n    const syntheticEvent: Types.TraceEvents.SyntheticScreenshot = {\n      cat,\n      name,\n      ph,\n      pid,\n      tid,\n      // `getPresentationTimestamp(snapshotEvent) - snapshotEvent.ts` is how many microsec the screenshot was adjusted to the right/later\n      ts: getPresentationTimestamp(snapshotEvent),\n      args: {\n        dataUri: `data:image/jpg;base64,${snapshotEvent.args.snapshot}`,\n      },\n    };\n    syntheticScreenshotEvents.push(syntheticEvent);\n  }\n}\n\n/**\n * Correct the screenshot timestamps\n * The screenshot 'snapshot object' trace event has the \"frame sequence number\" attached as an ID.\n * We match that up with the \"PipelineReporter\" trace events as they terminate at presentation.\n * Presentation == when the pixels hit the screen. AKA Swap on the GPU\n */\nfunction getPresentationTimestamp(screenshotEvent: Types.TraceEvents.TraceEventScreenshot): Types.Timing.MicroSeconds {\n  const frameSequence = parseInt(screenshotEvent.id, 16);\n  // If it's 1, then it's an old trace (before https://crrev.com/c/4957973) and cannot be corrected.\n  if (frameSequence === 1) {\n    return screenshotEvent.ts;\n  }\n  // The screenshot trace event's `ts` reflects the \"expected display time\" which is ESTIMATE.\n  // It is set by the compositor frame sink from the `expected_display_time`, which is based on a previously known\n  // frame start PLUS the vsync interval (eg 16.6ms)\n  const updatedTs = frameSequenceToTs[frameSequence];\n  // Do we always find a match? No...\n  // We generally don't match the very first screenshot and, sometimes, the last\n  // The very first screenshot is requested immediately (even if nothing is painting). As a result there's no compositor\n  // instrumentation running alongside.\n  // The last one is sometimes missing as because the trace terminates right before the associated PipelineReporter is emitted.\n  return updatedTs ?? screenshotEvent.ts;\n}\n\nexport function data(): Types.TraceEvents.SyntheticScreenshot[] {\n  return [...syntheticScreenshotEvents];\n}\n\nexport function deps(): TraceEventHandlerName[] {\n  return ['Meta'];\n}\n"]}

package/models/trace/handlers/Threads.d.ts

@@ -0,0 +1,33 @@
+import type * as Helpers from '../helpers/helpers.js';
+import type * as Types from '../types/types.js';
+import { type AuctionWorkletsData } from './AuctionWorkletsHandler.js';
+import type * as Renderer from './RendererHandler.js';
+import { type TraceParseData } from './types.js';
+export interface ThreadData {
+    pid: Types.TraceEvents.ProcessID;
+    tid: Types.TraceEvents.ThreadID;
+    entries: readonly Types.TraceEvents.SyntheticTraceEntry[];
+    processIsOnMainFrame: boolean;
+    tree: Helpers.TreeHelpers.TraceEntryTree;
+    type: ThreadType;
+    name: string | null;
+    entryToNode: Map<Types.TraceEvents.SyntheticTraceEntry, Helpers.TreeHelpers.TraceEntryNode>;
+}
+export declare const enum ThreadType {
+    MAIN_THREAD = "MAIN_THREAD",
+    WORKER = "WORKER",
+    RASTERIZER = "RASTERIZER",
+    AUCTION_WORKLET = "AUCTION_WORKLET",
+    OTHER = "OTHER",
+    CPU_PROFILE = "CPU_PROFILE",
+    THREAD_POOL = "THREAD_POOL"
+}
+export declare function threadsInRenderer(rendererData: Renderer.RendererHandlerData, auctionWorkletsData: AuctionWorkletsData): readonly ThreadData[];
+/**
+ * Given trace parsed data, this helper will return a high level array of
+ * ThreadData. This is useful because it allows you to get a list of threads
+ * regardless of if the trace is a CPU Profile or a Tracing profile. Thus you
+ * can use this helper to iterate over threads in confidence that it will work
+ * for both trace types.
+ */
+export declare function threadsInTrace(traceParseData: TraceParseData): readonly ThreadData[];

package/models/trace/handlers/Threads.js

@@ -1,77 +1,95 @@
-export var ThreadType = /* @__PURE__ */ ((ThreadType2) => {
-  ThreadType2["MAIN_THREAD"] = "MAIN_THREAD";
-  ThreadType2["WORKER"] = "WORKER";
-  ThreadType2["RASTERIZER"] = "RASTERIZER";
-  ThreadType2["AUCTION_WORKLET"] = "AUCTION_WORKLET";
-  ThreadType2["OTHER"] = "OTHER";
-  ThreadType2["CPU_PROFILE"] = "CPU_PROFILE";
-  ThreadType2["THREAD_POOL"] = "THREAD_POOL";
-  return ThreadType2;
-})(ThreadType || {});
 function getThreadTypeForRendererThread(auctionWorkletsData, pid, thread) {
-  let threadType = "OTHER" /* OTHER */;
-  if (thread.name === "CrRendererMain") {
-    threadType = "MAIN_THREAD" /* MAIN_THREAD */;
-  } else if (thread.name === "DedicatedWorker thread") {
-    threadType = "WORKER" /* WORKER */;
-  } else if (thread.name?.startsWith("CompositorTileWorker")) {
-    threadType = "RASTERIZER" /* RASTERIZER */;
-  } else if (auctionWorkletsData.worklets.has(pid)) {
-    threadType = "AUCTION_WORKLET" /* AUCTION_WORKLET */;
-  } else if (thread.name?.startsWith("ThreadPool")) {
-    threadType = "THREAD_POOL" /* THREAD_POOL */;
-  }
-  return threadType;
+    let threadType = "OTHER" /* ThreadType.OTHER */;
+    if (thread.name === 'CrRendererMain') {
+        threadType = "MAIN_THREAD" /* ThreadType.MAIN_THREAD */;
+    }
+    else if (thread.name === 'DedicatedWorker thread') {
+        threadType = "WORKER" /* ThreadType.WORKER */;
+    }
+    else if (thread.name?.startsWith('CompositorTileWorker')) {
+        threadType = "RASTERIZER" /* ThreadType.RASTERIZER */;
+    }
+    else if (auctionWorkletsData.worklets.has(pid)) {
+        threadType = "AUCTION_WORKLET" /* ThreadType.AUCTION_WORKLET */;
+    }
+    else if (thread.name?.startsWith('ThreadPool')) {
+        // TODO(paulirish): perhaps exclude ThreadPoolServiceThread entirely
+        threadType = "THREAD_POOL" /* ThreadType.THREAD_POOL */;
+    }
+    return threadType;
 }
 export function threadsInRenderer(rendererData, auctionWorkletsData) {
-  const foundThreads = [];
-  if (rendererData.processes.size) {
-    for (const [pid, process] of rendererData.processes) {
-      for (const [tid, thread] of process.threads) {
-        if (!thread.tree) {
-          continue;
+    const foundThreads = [];
+    // If we have Renderer threads, we prefer to use those. In the event that a
+    // trace is a CPU Profile trace, we will never have Renderer threads, so we
+    // know if there are no Renderer threads that we can fallback to using the
+    // data from the SamplesHandler.
+    if (rendererData.processes.size) {
+        for (const [pid, process] of rendererData.processes) {
+            for (const [tid, thread] of process.threads) {
+                if (!thread.tree) {
+                    // Drop threads where we could not create the tree; this indicates
+                    // unexpected data and we won't be able to support all the UI
+                    // filtering we need.
+                    continue;
+                }
+                const threadType = getThreadTypeForRendererThread(auctionWorkletsData, pid, thread);
+                foundThreads.push({
+                    name: thread.name,
+                    pid,
+                    tid,
+                    processIsOnMainFrame: process.isOnMainFrame,
+                    entries: thread.entries,
+                    tree: thread.tree,
+                    type: threadType,
+                    entryToNode: rendererData.entryToNode,
+                });
+            }
         }
-        const threadType = getThreadTypeForRendererThread(auctionWorkletsData, pid, thread);
-        foundThreads.push({
-          name: thread.name,
-          pid,
-          tid,
-          processIsOnMainFrame: process.isOnMainFrame,
-          entries: thread.entries,
-          tree: thread.tree,
-          type: threadType,
-          entryToNode: rendererData.entryToNode
-        });
-      }
     }
-  }
-  return foundThreads;
+    return foundThreads;
 }
+/**
+ * Given trace parsed data, this helper will return a high level array of
+ * ThreadData. This is useful because it allows you to get a list of threads
+ * regardless of if the trace is a CPU Profile or a Tracing profile. Thus you
+ * can use this helper to iterate over threads in confidence that it will work
+ * for both trace types.
+ */
 export function threadsInTrace(traceParseData) {
-  const threadsFromRenderer = threadsInRenderer(traceParseData.Renderer, traceParseData.AuctionWorklets);
-  if (threadsFromRenderer.length) {
-    return threadsFromRenderer;
-  }
-  const foundThreads = [];
-  if (traceParseData.Samples.profilesInProcess.size) {
-    for (const [pid, process] of traceParseData.Samples.profilesInProcess) {
-      for (const [tid, thread] of process) {
-        if (!thread.profileTree) {
-          continue;
+    // If we have Renderer threads, we prefer to use those. In the event that a
+    // trace is a CPU Profile trace, we will never have Renderer threads, so we
+    // know if there are no Renderer threads that we can fallback to using the
+    // data from the SamplesHandler.
+    const threadsFromRenderer = threadsInRenderer(traceParseData.Renderer, traceParseData.AuctionWorklets);
+    if (threadsFromRenderer.length) {
+        return threadsFromRenderer;
+    }
+    const foundThreads = [];
+    if (traceParseData.Samples.profilesInProcess.size) {
+        for (const [pid, process] of traceParseData.Samples.profilesInProcess) {
+            for (const [tid, thread] of process) {
+                if (!thread.profileTree) {
+                    // Drop threads where we could not create the tree; this indicates
+                    // unexpected data and we won't be able to support all the UI
+                    // filtering we need.
+                    continue;
+                }
+                foundThreads.push({
+                    pid,
+                    tid,
+                    // CPU Profile threads do not have a name.
+                    name: null,
+                    entries: thread.profileCalls,
+                    // There is no concept of a "Main Frame" in a CPU profile.
+                    processIsOnMainFrame: false,
+                    tree: thread.profileTree,
+                    type: "CPU_PROFILE" /* ThreadType.CPU_PROFILE */,
+                    entryToNode: traceParseData.Samples.entryToNode,
+                });
+            }
         }
-        foundThreads.push({
-          pid,
-          tid,
-          name: null,
-          entries: thread.profileCalls,
-          processIsOnMainFrame: false,
-          tree: thread.profileTree,
-          type: "CPU_PROFILE" /* CPU_PROFILE */,
-          entryToNode: traceParseData.Samples.entryToNode
-        });
-      }
     }
-  }
-  return foundThreads;
+    return foundThreads;
 }
-//# sourceMappingURL=Threads.js.map
+//# sourceMappingURL=Threads.js.map

package/models/trace/handlers/Threads.js.map

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../front_end/models/trace/handlers/Threads.ts"],
-  "sourcesContent": ["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n//\nimport type * as Helpers from '../helpers/helpers.js';\nimport type * as Types from '../types/types.js';\n\nimport {type AuctionWorkletsData} from './AuctionWorkletsHandler.js';\nimport type * as Renderer from './RendererHandler.js';\nimport {type TraceParseData} from './types.js';\n\nexport interface ThreadData {\n  pid: Types.TraceEvents.ProcessID;\n  tid: Types.TraceEvents.ThreadID;\n  entries: readonly Types.TraceEvents.SyntheticTraceEntry[];\n  processIsOnMainFrame: boolean;\n  tree: Helpers.TreeHelpers.TraceEntryTree;\n  type: ThreadType;\n  name: string|null;\n  entryToNode: Map<Types.TraceEvents.SyntheticTraceEntry, Helpers.TreeHelpers.TraceEntryNode>;\n}\n\nexport const enum ThreadType {\n  MAIN_THREAD = 'MAIN_THREAD',\n  WORKER = 'WORKER',\n  RASTERIZER = 'RASTERIZER',\n  AUCTION_WORKLET = 'AUCTION_WORKLET',\n  OTHER = 'OTHER',\n  CPU_PROFILE = 'CPU_PROFILE',\n  THREAD_POOL = 'THREAD_POOL',\n}\n\nfunction getThreadTypeForRendererThread(\n    auctionWorkletsData: AuctionWorkletsData, pid: Types.TraceEvents.ProcessID,\n    thread: Renderer.RendererThread): ThreadType {\n  let threadType = ThreadType.OTHER;\n  if (thread.name === 'CrRendererMain') {\n    threadType = ThreadType.MAIN_THREAD;\n  } else if (thread.name === 'DedicatedWorker thread') {\n    threadType = ThreadType.WORKER;\n  } else if (thread.name?.startsWith('CompositorTileWorker')) {\n    threadType = ThreadType.RASTERIZER;\n  } else if (auctionWorkletsData.worklets.has(pid)) {\n    threadType = ThreadType.AUCTION_WORKLET;\n  } else if (thread.name?.startsWith('ThreadPool')) {\n    // TODO(paulirish): perhaps exclude ThreadPoolServiceThread entirely\n    threadType = ThreadType.THREAD_POOL;\n  }\n  return threadType;\n}\n\nexport function threadsInRenderer(\n    rendererData: Renderer.RendererHandlerData, auctionWorkletsData: AuctionWorkletsData): readonly ThreadData[] {\n  const foundThreads: ThreadData[] = [];\n  // If we have Renderer threads, we prefer to use those. In the event that a\n  // trace is a CPU Profile trace, we will never have Renderer threads, so we\n  // know if there are no Renderer threads that we can fallback to using the\n  // data from the SamplesHandler.\n  if (rendererData.processes.size) {\n    for (const [pid, process] of rendererData.processes) {\n      for (const [tid, thread] of process.threads) {\n        if (!thread.tree) {\n          // Drop threads where we could not create the tree; this indicates\n          // unexpected data and we won't be able to support all the UI\n          // filtering we need.\n          continue;\n        }\n        const threadType = getThreadTypeForRendererThread(auctionWorkletsData, pid, thread);\n        foundThreads.push({\n          name: thread.name,\n          pid,\n          tid,\n          processIsOnMainFrame: process.isOnMainFrame,\n          entries: thread.entries,\n          tree: thread.tree,\n          type: threadType,\n          entryToNode: rendererData.entryToNode,\n        });\n      }\n    }\n  }\n  return foundThreads;\n}\n\n/**\n * Given trace parsed data, this helper will return a high level array of\n * ThreadData. This is useful because it allows you to get a list of threads\n * regardless of if the trace is a CPU Profile or a Tracing profile. Thus you\n * can use this helper to iterate over threads in confidence that it will work\n * for both trace types.\n */\nexport function threadsInTrace(traceParseData: TraceParseData): readonly ThreadData[] {\n  // If we have Renderer threads, we prefer to use those. In the event that a\n  // trace is a CPU Profile trace, we will never have Renderer threads, so we\n  // know if there are no Renderer threads that we can fallback to using the\n  // data from the SamplesHandler.\n  const threadsFromRenderer = threadsInRenderer(traceParseData.Renderer, traceParseData.AuctionWorklets);\n  if (threadsFromRenderer.length) {\n    return threadsFromRenderer;\n  }\n\n  const foundThreads: ThreadData[] = [];\n  if (traceParseData.Samples.profilesInProcess.size) {\n    for (const [pid, process] of traceParseData.Samples.profilesInProcess) {\n      for (const [tid, thread] of process) {\n        if (!thread.profileTree) {\n          // Drop threads where we could not create the tree; this indicates\n          // unexpected data and we won't be able to support all the UI\n          // filtering we need.\n          continue;\n        }\n\n        foundThreads.push({\n          pid,\n          tid,\n          // CPU Profile threads do not have a name.\n          name: null,\n          entries: thread.profileCalls,\n          // There is no concept of a \"Main Frame\" in a CPU profile.\n          processIsOnMainFrame: false,\n          tree: thread.profileTree,\n          type: ThreadType.CPU_PROFILE,\n          entryToNode: traceParseData.Samples.entryToNode,\n        });\n      }\n    }\n  }\n\n  return foundThreads;\n}\n"],
-  "mappings": "AAsBO,WAAW,aAAX,kBAAW,gBAAX;AACL,+BAAc;AACd,0BAAS;AACT,8BAAa;AACb,mCAAkB;AAClB,yBAAQ;AACR,+BAAc;AACd,+BAAc;AAPE;AAAA;AAUlB,wCACI,qBAA0C,KAC1C,QAA6C;AAC/C,MAAI,aAAa;AACjB,MAAI,OAAO,SAAS,kBAAkB;AACpC,iBAAa;AAAA,aACJ,OAAO,SAAS,0BAA0B;AACnD,iBAAa;AAAA,aACJ,OAAO,MAAM,WAAW,yBAAyB;AAC1D,iBAAa;AAAA,aACJ,oBAAoB,SAAS,IAAI,MAAM;AAChD,iBAAa;AAAA,aACJ,OAAO,MAAM,WAAW,eAAe;AAEhD,iBAAa;AAAA;AAEf,SAAO;AAAA;AAGF,kCACH,cAA4C,qBAAiE;AAC/G,QAAM,eAA6B;AAKnC,MAAI,aAAa,UAAU,MAAM;AAC/B,eAAW,CAAC,KAAK,YAAY,aAAa,WAAW;AACnD,iBAAW,CAAC,KAAK,WAAW,QAAQ,SAAS;AAC3C,YAAI,CAAC,OAAO,MAAM;AAIhB;AAAA;AAEF,cAAM,aAAa,+BAA+B,qBAAqB,KAAK;AAC5E,qBAAa,KAAK;AAAA,UAChB,MAAM,OAAO;AAAA,UACb;AAAA,UACA;AAAA,UACA,sBAAsB,QAAQ;AAAA,UAC9B,SAAS,OAAO;AAAA,UAChB,MAAM,OAAO;AAAA,UACb,MAAM;AAAA,UACN,aAAa,aAAa;AAAA;AAAA;AAAA;AAAA;AAKlC,SAAO;AAAA;AAUF,+BAAwB,gBAAuD;AAKpF,QAAM,sBAAsB,kBAAkB,eAAe,UAAU,eAAe;AACtF,MAAI,oBAAoB,QAAQ;AAC9B,WAAO;AAAA;AAGT,QAAM,eAA6B;AACnC,MAAI,eAAe,QAAQ,kBAAkB,MAAM;AACjD,eAAW,CAAC,KAAK,YAAY,eAAe,QAAQ,mBAAmB;AACrE,iBAAW,CAAC,KAAK,WAAW,SAAS;AACnC,YAAI,CAAC,OAAO,aAAa;AAIvB;AAAA;AAGF,qBAAa,KAAK;AAAA,UAChB;AAAA,UACA;AAAA,UAEA,MAAM;AAAA,UACN,SAAS,OAAO;AAAA,UAEhB,sBAAsB;AAAA,UACtB,MAAM,OAAO;AAAA,UACb,MAAM;AAAA,UACN,aAAa,eAAe,QAAQ;AAAA;AAAA;AAAA;AAAA;AAM5C,SAAO;AAAA;",
-  "names": []
-}
+{"version":3,"file":"Threads.js","sourceRoot":"","sources":["../../../../../../../front_end/models/trace/handlers/Threads.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n//\nimport type * as Helpers from '../helpers/helpers.js';\nimport type * as Types from '../types/types.js';\n\nimport {type AuctionWorkletsData} from './AuctionWorkletsHandler.js';\nimport type * as Renderer from './RendererHandler.js';\nimport {type TraceParseData} from './types.js';\n\nexport interface ThreadData {\n  pid: Types.TraceEvents.ProcessID;\n  tid: Types.TraceEvents.ThreadID;\n  entries: readonly Types.TraceEvents.SyntheticTraceEntry[];\n  processIsOnMainFrame: boolean;\n  tree: Helpers.TreeHelpers.TraceEntryTree;\n  type: ThreadType;\n  name: string|null;\n  entryToNode: Map<Types.TraceEvents.SyntheticTraceEntry, Helpers.TreeHelpers.TraceEntryNode>;\n}\n\nexport const enum ThreadType {\n  MAIN_THREAD = 'MAIN_THREAD',\n  WORKER = 'WORKER',\n  RASTERIZER = 'RASTERIZER',\n  AUCTION_WORKLET = 'AUCTION_WORKLET',\n  OTHER = 'OTHER',\n  CPU_PROFILE = 'CPU_PROFILE',\n  THREAD_POOL = 'THREAD_POOL',\n}\n\nfunction getThreadTypeForRendererThread(\n    auctionWorkletsData: AuctionWorkletsData, pid: Types.TraceEvents.ProcessID,\n    thread: Renderer.RendererThread): ThreadType {\n  let threadType = ThreadType.OTHER;\n  if (thread.name === 'CrRendererMain') {\n    threadType = ThreadType.MAIN_THREAD;\n  } else if (thread.name === 'DedicatedWorker thread') {\n    threadType = ThreadType.WORKER;\n  } else if (thread.name?.startsWith('CompositorTileWorker')) {\n    threadType = ThreadType.RASTERIZER;\n  } else if (auctionWorkletsData.worklets.has(pid)) {\n    threadType = ThreadType.AUCTION_WORKLET;\n  } else if (thread.name?.startsWith('ThreadPool')) {\n    // TODO(paulirish): perhaps exclude ThreadPoolServiceThread entirely\n    threadType = ThreadType.THREAD_POOL;\n  }\n  return threadType;\n}\n\nexport function threadsInRenderer(\n    rendererData: Renderer.RendererHandlerData, auctionWorkletsData: AuctionWorkletsData): readonly ThreadData[] {\n  const foundThreads: ThreadData[] = [];\n  // If we have Renderer threads, we prefer to use those. In the event that a\n  // trace is a CPU Profile trace, we will never have Renderer threads, so we\n  // know if there are no Renderer threads that we can fallback to using the\n  // data from the SamplesHandler.\n  if (rendererData.processes.size) {\n    for (const [pid, process] of rendererData.processes) {\n      for (const [tid, thread] of process.threads) {\n        if (!thread.tree) {\n          // Drop threads where we could not create the tree; this indicates\n          // unexpected data and we won't be able to support all the UI\n          // filtering we need.\n          continue;\n        }\n        const threadType = getThreadTypeForRendererThread(auctionWorkletsData, pid, thread);\n        foundThreads.push({\n          name: thread.name,\n          pid,\n          tid,\n          processIsOnMainFrame: process.isOnMainFrame,\n          entries: thread.entries,\n          tree: thread.tree,\n          type: threadType,\n          entryToNode: rendererData.entryToNode,\n        });\n      }\n    }\n  }\n  return foundThreads;\n}\n\n/**\n * Given trace parsed data, this helper will return a high level array of\n * ThreadData. This is useful because it allows you to get a list of threads\n * regardless of if the trace is a CPU Profile or a Tracing profile. Thus you\n * can use this helper to iterate over threads in confidence that it will work\n * for both trace types.\n */\nexport function threadsInTrace(traceParseData: TraceParseData): readonly ThreadData[] {\n  // If we have Renderer threads, we prefer to use those. In the event that a\n  // trace is a CPU Profile trace, we will never have Renderer threads, so we\n  // know if there are no Renderer threads that we can fallback to using the\n  // data from the SamplesHandler.\n  const threadsFromRenderer = threadsInRenderer(traceParseData.Renderer, traceParseData.AuctionWorklets);\n  if (threadsFromRenderer.length) {\n    return threadsFromRenderer;\n  }\n\n  const foundThreads: ThreadData[] = [];\n  if (traceParseData.Samples.profilesInProcess.size) {\n    for (const [pid, process] of traceParseData.Samples.profilesInProcess) {\n      for (const [tid, thread] of process) {\n        if (!thread.profileTree) {\n          // Drop threads where we could not create the tree; this indicates\n          // unexpected data and we won't be able to support all the UI\n          // filtering we need.\n          continue;\n        }\n\n        foundThreads.push({\n          pid,\n          tid,\n          // CPU Profile threads do not have a name.\n          name: null,\n          entries: thread.profileCalls,\n          // There is no concept of a \"Main Frame\" in a CPU profile.\n          processIsOnMainFrame: false,\n          tree: thread.profileTree,\n          type: ThreadType.CPU_PROFILE,\n          entryToNode: traceParseData.Samples.entryToNode,\n        });\n      }\n    }\n  }\n\n  return foundThreads;\n}\n"]}

package/models/trace/handlers/UserInteractionsHandler.d.ts

@@ -0,0 +1,57 @@
+import * as Types from '../types/types.js';
+export declare const LONG_INTERACTION_THRESHOLD: Types.Timing.MicroSeconds;
+export interface UserInteractionsData {
+    /** All the user events we found in the trace */
+    allEvents: readonly Types.TraceEvents.TraceEventEventTiming[];
+    /** All the interaction events we found in the trace that had an
+     * interactionId and a duration > 0
+     **/
+    interactionEvents: readonly Types.TraceEvents.SyntheticInteractionPair[];
+    /** If the user rapidly generates interaction events (think typing into a
+     * text box), in the UI we only really want to show the user the longest
+     * interaction in that set.
+     * For example picture interactions like this:
+     * ===[interaction A]==========
+     *       =[interaction B]======
+     *            =[interaction C]=
+     *
+     * These events all end at the same time, and so in this instance we only want
+     * to show the first interaction A on the timeline, as that is the longest one
+     * and the one the developer should be focusing on. So this array of events is
+     * all the interaction events filtered down, removing any nested interactions
+     * entirely.
+     **/
+    interactionEventsWithNoNesting: readonly Types.TraceEvents.SyntheticInteractionPair[];
+    longestInteractionEvent: Readonly<Types.TraceEvents.SyntheticInteractionPair> | null;
+    interactionsOverThreshold: Readonly<Set<Types.TraceEvents.SyntheticInteractionPair>>;
+}
+export declare function reset(): void;
+export declare function handleEvent(event: Types.TraceEvents.TraceEventData): void;
+export type InteractionCategory = 'KEYBOARD' | 'POINTER' | 'OTHER';
+export declare function categoryOfInteraction(interaction: Types.TraceEvents.SyntheticInteractionPair): InteractionCategory;
+/**
+ * We define a set of interactions as nested where:
+ * 1. Their end times align.
+ * 2. The longest interaction's start time is earlier than all other
+ * interactions with the same end time.
+ * 3. The interactions are of the same category [each interaction is either
+ * categorised as keyboard, or pointer.]
+ *
+ * =============A=[pointerup]=
+ *        ====B=[pointerdown]=
+ *        ===C=[pointerdown]==
+ *         ===D=[pointerup]===
+ *
+ * In this example, B, C and D are all nested and therefore should not be
+ * returned from this function.
+ *
+ * However, in this example we would only consider B nested (under A) and D
+ * nested (under C). A and C both stay because they are of different types.
+ * ========A=[keydown]====
+ *   =======B=[keyup]=====
+ *    ====C=[pointerdown]=
+ *         =D=[pointerup]=
+ **/
+export declare function removeNestedInteractions(interactions: readonly Types.TraceEvents.SyntheticInteractionPair[]): readonly Types.TraceEvents.SyntheticInteractionPair[];
+export declare function finalize(): Promise<void>;
+export declare function data(): UserInteractionsData;