@paulirish/trace_engine 0.0.8 → 0.0.10

package/models/trace/handlers/AuctionWorkletsHandler.js

@@ -0,0 +1,106 @@
+import * as Types from "../types/types.js";
+const runningInProcessEvents = /* @__PURE__ */ new Map();
+const doneWithProcessEvents = /* @__PURE__ */ new Map();
+const createdSyntheticEvents = /* @__PURE__ */ new Map();
+const utilityThreads = /* @__PURE__ */ new Map();
+const v8HelperThreads = /* @__PURE__ */ new Map();
+export function reset() {
+  runningInProcessEvents.clear();
+  doneWithProcessEvents.clear();
+  createdSyntheticEvents.clear();
+  utilityThreads.clear();
+  v8HelperThreads.clear();
+}
+export function handleEvent(event) {
+  if (Types.TraceEvents.isTraceEventAuctionWorkletRunningInProcess(event)) {
+    runningInProcessEvents.set(event.args.data.pid, event);
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventAuctionWorkletDoneWithProcess(event)) {
+    doneWithProcessEvents.set(event.args.data.pid, event);
+    return;
+  }
+  if (Types.TraceEvents.isThreadName(event)) {
+    if (event.args.name === "auction_worklet.CrUtilityMain") {
+      utilityThreads.set(event.pid, event);
+      return;
+    }
+    if (event.args.name === "AuctionV8HelperThread") {
+      v8HelperThreads.set(event.pid, event);
+    }
+  }
+}
+function workletType(input) {
+  switch (input) {
+    case "seller":
+      return Types.TraceEvents.AuctionWorkletType.SELLER;
+    case "bidder":
+      return Types.TraceEvents.AuctionWorkletType.BIDDER;
+    default:
+      return Types.TraceEvents.AuctionWorkletType.UNKNOWN;
+  }
+}
+function makeSyntheticEventBase(event) {
+  return {
+    name: "SyntheticAuctionWorkletEvent",
+    s: Types.TraceEvents.TraceEventScope.THREAD,
+    cat: event.cat,
+    tid: event.tid,
+    ts: event.ts,
+    ph: Types.TraceEvents.Phase.INSTANT,
+    pid: event.args.data.pid,
+    host: event.args.data.host,
+    target: event.args.data.target,
+    type: workletType(event.args.data.type)
+  };
+}
+export async function finalize() {
+  for (const [pid, utilityThreadNameEvent] of utilityThreads) {
+    const v8HelperEvent = v8HelperThreads.get(pid);
+    if (!v8HelperEvent) {
+      continue;
+    }
+    const runningEvent = runningInProcessEvents.get(pid);
+    const doneWithEvent = doneWithProcessEvents.get(pid);
+    let syntheticEvent = null;
+    if (runningEvent) {
+      syntheticEvent = {
+        ...makeSyntheticEventBase(runningEvent),
+        args: {
+          data: {
+            runningInProcessEvent: runningEvent,
+            utilityThread: utilityThreadNameEvent,
+            v8HelperThread: v8HelperEvent
+          }
+        }
+      };
+      if (doneWithEvent) {
+        syntheticEvent.args.data.doneWithProcessEvent = doneWithEvent;
+      }
+    } else if (doneWithEvent) {
+      syntheticEvent = {
+        ...makeSyntheticEventBase(doneWithEvent),
+        args: {
+          data: {
+            doneWithProcessEvent: doneWithEvent,
+            utilityThread: utilityThreadNameEvent,
+            v8HelperThread: v8HelperEvent
+          }
+        }
+      };
+      if (runningEvent) {
+        syntheticEvent.args.data.runningInProcessEvent = runningEvent;
+      }
+    }
+    if (syntheticEvent === null) {
+      continue;
+    }
+    createdSyntheticEvents.set(pid, syntheticEvent);
+  }
+}
+export function data() {
+  return {
+    worklets: new Map(createdSyntheticEvents)
+  };
+}
+//# sourceMappingURL=AuctionWorkletsHandler.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/AuctionWorkletsHandler.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 * as Types from '../types/types.js';\n\n/**\n * There are two metadata events that we care about.\n * => AuctionWorkletRunningInProcess tells us which process the Auction Worklet\n *    has taken to run in.\n * => AuctionWorkletDoneWithProcess tells us when the worklet is done with that\n *    process. This is less useful - but in the future we might want to surface\n *    this information so we still parse and return the event.\n *\n * It is important to note that the top level PID on these events is NOT the\n * PID that the worklet is running on; instead we have to look at its\n * args.data.pid property, which is the PID of the process that it is running\n * on.\n *\n * For any given RunningInProcess event, we would typically expect to see a\n * DoneWithProcess event, however this is not guaranteed, especially as users\n * can record any chunk of time in DevTools.\n *\n * Similarly, it is also possible to see a DoneWithProcess event without a\n * RunningInProcess event, if the user started recording after the auction\n * worklets started. Therefore we are happy to create\n * SyntheticAuctionWorkletEvents as long as we see just one of these events.\n *\n * If we do get two events and need to pair them, we can use the\n * args.data.target property, which is a string ID shared by both\n * events.\n */\nconst runningInProcessEvents:\n    Map<Types.TraceEvents.ProcessID, Types.TraceEvents.TraceEventAuctionWorkletRunningInProcess> = new Map();\nconst doneWithProcessEvents:\n    Map<Types.TraceEvents.ProcessID, Types.TraceEvents.TraceEventAuctionWorkletDoneWithProcess> = new Map();\n\n// Keyed by the PID defined in  `args.data.pid` on AuctionWorklet trace events..\nconst createdSyntheticEvents: Map<Types.TraceEvents.ProcessID, Types.TraceEvents.SyntheticAuctionWorkletEvent> =\n    new Map();\n\n// Each AuctonWorklet takes over a process and has 2 threads (that we care\n// about and want to show as tracks):\n// 1. A CrUtilityMain thread which is known as the \"control process\".\n// 2. A AuctionV8HelperThread which is the actual auction worklet and will be\n//    either a \"Seller\" or a \"Bidder\"\n// To detect these we look for the metadata thread_name events. We key these by\n// PID so that we can easily look them up later without having to loop through.\nconst utilityThreads: Map<Types.TraceEvents.ProcessID, Types.TraceEvents.TraceEventThreadName> = new Map();\nconst v8HelperThreads: Map<Types.TraceEvents.ProcessID, Types.TraceEvents.TraceEventThreadName> = new Map();\n\nexport function reset(): void {\n  runningInProcessEvents.clear();\n  doneWithProcessEvents.clear();\n  createdSyntheticEvents.clear();\n  utilityThreads.clear();\n  v8HelperThreads.clear();\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  if (Types.TraceEvents.isTraceEventAuctionWorkletRunningInProcess(event)) {\n    runningInProcessEvents.set(event.args.data.pid, event);\n    return;\n  }\n\n  if (Types.TraceEvents.isTraceEventAuctionWorkletDoneWithProcess(event)) {\n    doneWithProcessEvents.set(event.args.data.pid, event);\n    return;\n  }\n\n  if (Types.TraceEvents.isThreadName(event)) {\n    if (event.args.name === 'auction_worklet.CrUtilityMain') {\n      utilityThreads.set(event.pid, event);\n      return;\n    }\n    if (event.args.name === 'AuctionV8HelperThread') {\n      v8HelperThreads.set(event.pid, event);\n    }\n  }\n}\n\nfunction workletType(input: string): Types.TraceEvents.AuctionWorkletType {\n  switch (input) {\n    case 'seller':\n      return Types.TraceEvents.AuctionWorkletType.SELLER;\n    case 'bidder':\n      return Types.TraceEvents.AuctionWorkletType.BIDDER;\n    default:\n      return Types.TraceEvents.AuctionWorkletType.UNKNOWN;\n  }\n}\n\n/**\n * We cannot make the full event without knowing the type of event, but we can\n * create everything other than the `args` field, as those are identical\n * regardless of the type of event.\n */\nfunction makeSyntheticEventBase(event: Types.TraceEvents.TraceEventAuctionWorkletDoneWithProcess|\n                                Types.TraceEvents.TraceEventAuctionWorkletRunningInProcess):\n    Omit<Types.TraceEvents.SyntheticAuctionWorkletEvent, 'args'> {\n  return {\n    name: 'SyntheticAuctionWorkletEvent',\n    s: Types.TraceEvents.TraceEventScope.THREAD,\n    cat: event.cat,\n    tid: event.tid,\n    ts: event.ts,\n    ph: Types.TraceEvents.Phase.INSTANT,\n    pid: event.args.data.pid,\n    host: event.args.data.host,\n    target: event.args.data.target,\n    type: workletType(event.args.data.type),\n  };\n}\n\nexport async function finalize(): Promise<void> {\n  // Loop through the utility threads we found to create the worklet events. We\n  // expect each worklet to have a utility thread, so we can use them as the\n  // root of our list of worklets.\n  for (const [pid, utilityThreadNameEvent] of utilityThreads) {\n    const v8HelperEvent = v8HelperThreads.get(pid);\n    if (!v8HelperEvent) {\n      // Bad trace data - AuctionWorklets are expected to always have both threads.\n      continue;\n    }\n\n    const runningEvent = runningInProcessEvents.get(pid);\n    const doneWithEvent = doneWithProcessEvents.get(pid);\n\n    // We can create a worklet from either the runningEvent or doneWithEvent -\n    // we do not need both. We cannot express that to TypeScript with an early\n    // return here, so instead we set the event initially to null, and then\n    // create it from either the running event or the doneWith event. If it is\n    // still null after this, that means neither event was found, and we drop\n    // the worklet as we do not have enough information to create the synthetic\n    // event.\n\n    let syntheticEvent: Types.TraceEvents.SyntheticAuctionWorkletEvent|null = null;\n\n    if (runningEvent) {\n      syntheticEvent = {\n        ...makeSyntheticEventBase(runningEvent),\n        args: {\n          data: {\n            runningInProcessEvent: runningEvent,\n            utilityThread: utilityThreadNameEvent,\n            v8HelperThread: v8HelperEvent,\n          },\n        },\n      };\n      if (doneWithEvent) {\n        syntheticEvent.args.data.doneWithProcessEvent = doneWithEvent;\n      }\n    } else if (doneWithEvent) {\n      syntheticEvent = {\n        ...makeSyntheticEventBase(doneWithEvent),\n        args: {\n          data: {\n            doneWithProcessEvent: doneWithEvent,\n            utilityThread: utilityThreadNameEvent,\n            v8HelperThread: v8HelperEvent,\n          },\n        },\n      };\n      if (runningEvent) {\n        syntheticEvent.args.data.runningInProcessEvent = runningEvent;\n      }\n    }\n    if (syntheticEvent === null) {\n      continue;\n    }\n    createdSyntheticEvents.set(pid, syntheticEvent);\n  }\n}\n\nexport interface AuctionWorkletsData {\n  worklets: Map<Types.TraceEvents.ProcessID, Types.TraceEvents.SyntheticAuctionWorkletEvent>;\n}\n\nexport function data(): AuctionWorkletsData {\n  return {\n    worklets: new Map(createdSyntheticEvents),\n  };\n}\n"],
+  "mappings": "AAIA;AA4BA,MAAM,yBAC6F,oBAAI;AACvG,MAAM,wBAC4F,oBAAI;AAGtG,MAAM,yBACF,oBAAI;AASR,MAAM,iBAA2F,oBAAI;AACrG,MAAM,kBAA4F,oBAAI;AAE/F,wBAAuB;AAC5B,yBAAuB;AACvB,wBAAsB;AACtB,yBAAuB;AACvB,iBAAe;AACf,kBAAgB;AAAA;AAGX,4BAAqB,OAA+C;AACzE,MAAI,MAAM,YAAY,2CAA2C,QAAQ;AACvE,2BAAuB,IAAI,MAAM,KAAK,KAAK,KAAK;AAChD;AAAA;AAGF,MAAI,MAAM,YAAY,0CAA0C,QAAQ;AACtE,0BAAsB,IAAI,MAAM,KAAK,KAAK,KAAK;AAC/C;AAAA;AAGF,MAAI,MAAM,YAAY,aAAa,QAAQ;AACzC,QAAI,MAAM,KAAK,SAAS,iCAAiC;AACvD,qBAAe,IAAI,MAAM,KAAK;AAC9B;AAAA;AAEF,QAAI,MAAM,KAAK,SAAS,yBAAyB;AAC/C,sBAAgB,IAAI,MAAM,KAAK;AAAA;AAAA;AAAA;AAKrC,qBAAqB,OAAqD;AACxE,UAAQ;AAAA,SACD;AACH,aAAO,MAAM,YAAY,mBAAmB;AAAA,SACzC;AACH,aAAO,MAAM,YAAY,mBAAmB;AAAA;AAE5C,aAAO,MAAM,YAAY,mBAAmB;AAAA;AAAA;AASlD,gCAAgC,OAEiC;AAC/D,SAAO;AAAA,IACL,MAAM;AAAA,IACN,GAAG,MAAM,YAAY,gBAAgB;AAAA,IACrC,KAAK,MAAM;AAAA,IACX,KAAK,MAAM;AAAA,IACX,IAAI,MAAM;AAAA,IACV,IAAI,MAAM,YAAY,MAAM;AAAA,IAC5B,KAAK,MAAM,KAAK,KAAK;AAAA,IACrB,MAAM,MAAM,KAAK,KAAK;AAAA,IACtB,QAAQ,MAAM,KAAK,KAAK;AAAA,IACxB,MAAM,YAAY,MAAM,KAAK,KAAK;AAAA;AAAA;AAItC,iCAAgD;AAI9C,aAAW,CAAC,KAAK,2BAA2B,gBAAgB;AAC1D,UAAM,gBAAgB,gBAAgB,IAAI;AAC1C,QAAI,CAAC,eAAe;AAElB;AAAA;AAGF,UAAM,eAAe,uBAAuB,IAAI;AAChD,UAAM,gBAAgB,sBAAsB,IAAI;AAUhD,QAAI,iBAAsE;AAE1E,QAAI,cAAc;AAChB,uBAAiB;AAAA,WACZ,uBAAuB;AAAA,QAC1B,MAAM;AAAA,UACJ,MAAM;AAAA,YACJ,uBAAuB;AAAA,YACvB,eAAe;AAAA,YACf,gBAAgB;AAAA;AAAA;AAAA;AAItB,UAAI,eAAe;AACjB,uBAAe,KAAK,KAAK,uBAAuB;AAAA;AAAA,eAEzC,eAAe;AACxB,uBAAiB;AAAA,WACZ,uBAAuB;AAAA,QAC1B,MAAM;AAAA,UACJ,MAAM;AAAA,YACJ,sBAAsB;AAAA,YACtB,eAAe;AAAA,YACf,gBAAgB;AAAA;AAAA;AAAA;AAItB,UAAI,cAAc;AAChB,uBAAe,KAAK,KAAK,wBAAwB;AAAA;AAAA;AAGrD,QAAI,mBAAmB,MAAM;AAC3B;AAAA;AAEF,2BAAuB,IAAI,KAAK;AAAA;AAAA;AAQ7B,uBAAqC;AAC1C,SAAO;AAAA,IACL,UAAU,IAAI,IAAI;AAAA;AAAA;",
+  "names": []
+}

package/models/trace/handlers/FramesHandler.js

@@ -0,0 +1,388 @@
+import * as Platform from "../../../core/platform/platform.js";
+import * as Helpers from "../helpers/helpers.js";
+import * as Types from "../types/types.js";
+import { data as auctionWorkletsData } from "./AuctionWorkletsHandler.js";
+import { data as layerTreeHandlerData } from "./LayerTreeHandler.js";
+import { data as metaHandlerData } from "./MetaHandler.js";
+import { data as rendererHandlerData } from "./RendererHandler.js";
+import * as Threads from "./Threads.js";
+import { HandlerState } from "./types.js";
+let handlerState = HandlerState.UNINITIALIZED;
+const allEvents = [];
+let model = null;
+export function reset() {
+  handlerState = HandlerState.UNINITIALIZED;
+  allEvents.length = 0;
+}
+export function initialize() {
+  if (handlerState !== HandlerState.UNINITIALIZED) {
+    throw new Error("FramesHandler was not reset before being initialized");
+  }
+  handlerState = HandlerState.INITIALIZED;
+}
+export function handleEvent(event) {
+  allEvents.push(event);
+}
+export async function finalize() {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("FramesHandler is not initialized");
+  }
+  Helpers.Trace.sortTraceEventsInPlace(allEvents);
+  const modelForTrace = new TimelineFrameModel(allEvents, rendererHandlerData(), auctionWorkletsData(), metaHandlerData(), layerTreeHandlerData());
+  model = modelForTrace;
+}
+export function data() {
+  return {
+    frames: model ? Array.from(model.frames()) : [],
+    framesById: model ? { ...model.framesById() } : {}
+  };
+}
+export function deps() {
+  return ["Meta", "Renderer", "AuctionWorklets", "LayerTree"];
+}
+function isFrameEvent(event) {
+  return Types.TraceEvents.isTraceEventSetLayerId(event) || Types.TraceEvents.isTraceEventBeginFrame(event) || Types.TraceEvents.isTraceEventDroppedFrame(event) || Types.TraceEvents.isTraceEventRequestMainThreadFrame(event) || Types.TraceEvents.isTraceEventBeginMainThreadFrame(event) || Types.TraceEvents.isTraceEventNeedsBeginFrameChanged(event) || Types.TraceEvents.isTraceEventCommit(event) || Types.TraceEvents.isTraceEventCompositeLayers(event) || Types.TraceEvents.isTraceEventActivateLayerTree(event) || Types.TraceEvents.isTraceEventDrawFrame(event);
+}
+function entryIsTopLevel(entry) {
+  const devtoolsTimelineCategory = "disabled-by-default-devtools.timeline";
+  return entry.name === Types.TraceEvents.KnownEventName.RunTask && entry.cat.includes(devtoolsTimelineCategory);
+}
+export class TimelineFrameModel {
+  #frames = [];
+  #frameById = {};
+  #beginFrameQueue = new TimelineFrameBeginFrameQueue();
+  #lastFrame = null;
+  #mainFrameCommitted = false;
+  #mainFrameRequested = false;
+  #lastLayerTree = null;
+  #framePendingActivation = null;
+  #framePendingCommit = null;
+  #lastBeginFrame = null;
+  #lastNeedsBeginFrame = null;
+  #lastTaskBeginTime = null;
+  #layerTreeId = null;
+  #activeProcessId = null;
+  #activeThreadId = null;
+  #layerTreeData;
+  constructor(allEvents2, rendererData, auctionWorkletsData2, metaData, layerTreeData) {
+    const mainThreads = Threads.threadsInRenderer(rendererData, auctionWorkletsData2).filter((thread) => {
+      return thread.type === Threads.ThreadType.MAIN_THREAD && thread.processIsOnMainFrame;
+    });
+    const threadData = mainThreads.map((thread) => {
+      return {
+        tid: thread.tid,
+        pid: thread.pid,
+        startTime: thread.entries[0].ts
+      };
+    });
+    this.#layerTreeData = layerTreeData;
+    this.#addTraceEvents(allEvents2, threadData, metaData.mainFrameId);
+  }
+  framesById() {
+    return this.#frameById;
+  }
+  frames() {
+    return this.#frames;
+  }
+  #handleBeginFrame(startTime, seqId) {
+    if (!this.#lastFrame) {
+      this.#startFrame(startTime, seqId);
+    }
+    this.#lastBeginFrame = startTime;
+    this.#beginFrameQueue.addFrameIfNotExists(seqId, startTime, false, false);
+  }
+  #handleDroppedFrame(startTime, seqId, isPartial) {
+    if (!this.#lastFrame) {
+      this.#startFrame(startTime, seqId);
+    }
+    this.#beginFrameQueue.addFrameIfNotExists(seqId, startTime, true, isPartial);
+    this.#beginFrameQueue.setDropped(seqId, true);
+    this.#beginFrameQueue.setPartial(seqId, isPartial);
+  }
+  #handleDrawFrame(startTime, seqId) {
+    if (!this.#lastFrame) {
+      this.#startFrame(startTime, seqId);
+      return;
+    }
+    if (this.#mainFrameCommitted || !this.#mainFrameRequested) {
+      if (this.#lastNeedsBeginFrame) {
+        const idleTimeEnd = this.#framePendingActivation ? this.#framePendingActivation.triggerTime : this.#lastBeginFrame || this.#lastNeedsBeginFrame;
+        if (idleTimeEnd > this.#lastFrame.startTime) {
+          this.#lastFrame.idle = true;
+          this.#lastBeginFrame = null;
+        }
+        this.#lastNeedsBeginFrame = null;
+      }
+      const framesToVisualize = this.#beginFrameQueue.processPendingBeginFramesOnDrawFrame(seqId);
+      for (const frame of framesToVisualize) {
+        const isLastFrameIdle = this.#lastFrame.idle;
+        this.#startFrame(frame.startTime, seqId);
+        if (isLastFrameIdle && this.#framePendingActivation) {
+          this.#commitPendingFrame();
+        }
+        if (frame.isDropped) {
+          this.#lastFrame.dropped = true;
+        }
+        if (frame.isPartial) {
+          this.#lastFrame.isPartial = true;
+        }
+      }
+    }
+    this.#mainFrameCommitted = false;
+  }
+  #handleActivateLayerTree() {
+    if (!this.#lastFrame) {
+      return;
+    }
+    if (this.#framePendingActivation && !this.#lastNeedsBeginFrame) {
+      this.#commitPendingFrame();
+    }
+  }
+  #handleRequestMainThreadFrame() {
+    if (!this.#lastFrame) {
+      return;
+    }
+    this.#mainFrameRequested = true;
+  }
+  #handleCommit() {
+    if (!this.#framePendingCommit) {
+      return;
+    }
+    this.#framePendingActivation = this.#framePendingCommit;
+    this.#framePendingCommit = null;
+    this.#mainFrameRequested = false;
+    this.#mainFrameCommitted = true;
+  }
+  #handleLayerTreeSnapshot(layerTree) {
+    this.#lastLayerTree = layerTree;
+  }
+  #handleNeedFrameChanged(startTime, needsBeginFrame) {
+    if (needsBeginFrame) {
+      this.#lastNeedsBeginFrame = startTime;
+    }
+  }
+  #startFrame(startTime, seqId) {
+    if (this.#lastFrame) {
+      this.#flushFrame(this.#lastFrame, startTime);
+    }
+    this.#lastFrame = new TimelineFrame(seqId, startTime, Types.Timing.MicroSeconds(startTime - metaHandlerData().traceBounds.min));
+  }
+  #flushFrame(frame, endTime) {
+    frame.setLayerTree(this.#lastLayerTree);
+    frame.setEndTime(endTime);
+    if (this.#lastLayerTree) {
+      this.#lastLayerTree.paints = frame.paints;
+    }
+    const lastFrame = this.#frames[this.#frames.length - 1];
+    if (this.#frames.length && lastFrame && (frame.startTime !== lastFrame.endTime || frame.startTime > frame.endTime)) {
+      console.assert(false, `Inconsistent frame time for frame ${this.#frames.length} (${frame.startTime} - ${frame.endTime})`);
+    }
+    this.#frames.push(frame);
+    if (typeof frame.mainFrameId === "number") {
+      this.#frameById[frame.mainFrameId] = frame;
+    }
+  }
+  #commitPendingFrame() {
+    if (!this.#framePendingActivation || !this.#lastFrame) {
+      return;
+    }
+    this.#lastFrame.paints = this.#framePendingActivation.paints;
+    this.#lastFrame.mainFrameId = this.#framePendingActivation.mainFrameId;
+    this.#framePendingActivation = null;
+  }
+  #addTraceEvents(events, threadData, mainFrameId) {
+    let j = 0;
+    this.#activeThreadId = threadData.length && threadData[0].tid || null;
+    this.#activeProcessId = threadData.length && threadData[0].pid || null;
+    for (let i = 0; i < events.length; ++i) {
+      while (j + 1 < threadData.length && threadData[j + 1].startTime <= events[i].ts) {
+        this.#activeThreadId = threadData[++j].tid;
+        this.#activeProcessId = threadData[j].pid;
+      }
+      this.#addTraceEvent(events[i], mainFrameId);
+    }
+    this.#activeThreadId = null;
+    this.#activeProcessId = null;
+  }
+  #addTraceEvent(event, mainFrameId) {
+    if (Types.TraceEvents.isTraceEventSetLayerId(event) && event.args.data.frame === mainFrameId) {
+      this.#layerTreeId = event.args.data.layerTreeId;
+    } else if (Types.TraceEvents.isTraceEventLayerTreeHostImplSnapshot(event) && Number(event.id) === this.#layerTreeId) {
+      this.#handleLayerTreeSnapshot({
+        entry: event,
+        paints: []
+      });
+    } else {
+      if (isFrameEvent(event)) {
+        this.#processCompositorEvents(event);
+      }
+      if (event.tid === this.#activeThreadId && event.pid === this.#activeProcessId) {
+        this.#addMainThreadTraceEvent(event);
+      }
+    }
+  }
+  #processCompositorEvents(entry) {
+    if (entry.args["layerTreeId"] !== this.#layerTreeId) {
+      return;
+    }
+    if (Types.TraceEvents.isTraceEventBeginFrame(entry)) {
+      this.#handleBeginFrame(entry.ts, entry.args["frameSeqId"]);
+    } else if (Types.TraceEvents.isTraceEventDrawFrame(entry)) {
+      this.#handleDrawFrame(entry.ts, entry.args["frameSeqId"]);
+    } else if (Types.TraceEvents.isTraceEventActivateLayerTree(entry)) {
+      this.#handleActivateLayerTree();
+    } else if (Types.TraceEvents.isTraceEventRequestMainThreadFrame(entry)) {
+      this.#handleRequestMainThreadFrame();
+    } else if (Types.TraceEvents.isTraceEventNeedsBeginFrameChanged(entry)) {
+      this.#handleNeedFrameChanged(entry.ts, entry.args["data"] && Boolean(entry.args["data"]["needsBeginFrame"]));
+    } else if (Types.TraceEvents.isTraceEventDroppedFrame(entry)) {
+      this.#handleDroppedFrame(entry.ts, entry.args["frameSeqId"], Boolean(entry.args["hasPartialUpdate"]));
+    }
+  }
+  #addMainThreadTraceEvent(entry) {
+    if (entryIsTopLevel(entry)) {
+      this.#lastTaskBeginTime = entry.ts;
+    }
+    if (!this.#framePendingCommit && MAIN_FRAME_MARKERS.has(entry.name)) {
+      this.#framePendingCommit = new PendingFrame(this.#lastTaskBeginTime || entry.ts);
+    }
+    if (!this.#framePendingCommit) {
+      return;
+    }
+    if (Types.TraceEvents.isTraceEventBeginMainThreadFrame(entry) && entry.args.data.frameId) {
+      this.#framePendingCommit.mainFrameId = entry.args.data.frameId;
+    }
+    if (Types.TraceEvents.isTraceEventPaint(entry)) {
+      const snapshot = this.#layerTreeData.paintsToSnapshots.get(entry);
+      if (snapshot) {
+        this.#framePendingCommit.paints.push(new LayerPaintEvent(entry, snapshot));
+      }
+    }
+    if ((Types.TraceEvents.isTraceEventCompositeLayers(entry) || Types.TraceEvents.isTraceEventCommit(entry)) && entry.args["layerTreeId"] === this.#layerTreeId) {
+      this.#handleCommit();
+    }
+  }
+}
+const MAIN_FRAME_MARKERS = /* @__PURE__ */ new Set([
+  Types.TraceEvents.KnownEventName.ScheduleStyleRecalculation,
+  Types.TraceEvents.KnownEventName.InvalidateLayout,
+  Types.TraceEvents.KnownEventName.BeginMainThreadFrame,
+  Types.TraceEvents.KnownEventName.ScrollLayer
+]);
+export class TimelineFrame {
+  startTime;
+  startTimeOffset;
+  endTime;
+  duration;
+  idle;
+  dropped;
+  isPartial;
+  layerTree;
+  paints;
+  mainFrameId;
+  seqId;
+  constructor(seqId, startTime, startTimeOffset) {
+    this.seqId = seqId;
+    this.startTime = startTime;
+    this.startTimeOffset = startTimeOffset;
+    this.endTime = this.startTime;
+    this.duration = Types.Timing.MicroSeconds(0);
+    this.idle = false;
+    this.dropped = false;
+    this.isPartial = false;
+    this.layerTree = null;
+    this.paints = [];
+    this.mainFrameId = void 0;
+  }
+  setEndTime(endTime) {
+    this.endTime = endTime;
+    this.duration = Types.Timing.MicroSeconds(this.endTime - this.startTime);
+  }
+  setLayerTree(layerTree) {
+    this.layerTree = layerTree;
+  }
+}
+export class LayerPaintEvent {
+  #event;
+  #snapshot;
+  constructor(event, snapshot) {
+    this.#event = event;
+    this.#snapshot = snapshot;
+  }
+  layerId() {
+    return this.#event.args.data.layerId;
+  }
+  event() {
+    return this.#event;
+  }
+  picture() {
+    const rect = this.#snapshot.args.snapshot.params?.layer_rect;
+    const pictureData = this.#snapshot.args.snapshot.skp64;
+    return rect && pictureData ? { rect, serializedPicture: pictureData } : null;
+  }
+}
+export class PendingFrame {
+  paints;
+  mainFrameId;
+  triggerTime;
+  constructor(triggerTime) {
+    this.paints = [];
+    this.mainFrameId = void 0;
+    this.triggerTime = triggerTime;
+  }
+}
+class BeginFrameInfo {
+  seqId;
+  startTime;
+  isDropped;
+  isPartial;
+  constructor(seqId, startTime, isDropped, isPartial) {
+    this.seqId = seqId;
+    this.startTime = startTime;
+    this.isDropped = isDropped;
+    this.isPartial = isPartial;
+  }
+}
+export class TimelineFrameBeginFrameQueue {
+  queueFrames = [];
+  mapFrames = {};
+  addFrameIfNotExists(seqId, startTime, isDropped, isPartial) {
+    if (!(seqId in this.mapFrames)) {
+      this.mapFrames[seqId] = new BeginFrameInfo(seqId, startTime, isDropped, isPartial);
+      this.queueFrames.push(seqId);
+    }
+  }
+  setDropped(seqId, isDropped) {
+    if (seqId in this.mapFrames) {
+      this.mapFrames[seqId].isDropped = isDropped;
+    }
+  }
+  setPartial(seqId, isPartial) {
+    if (seqId in this.mapFrames) {
+      this.mapFrames[seqId].isPartial = isPartial;
+    }
+  }
+  processPendingBeginFramesOnDrawFrame(seqId) {
+    const framesToVisualize = [];
+    if (seqId in this.mapFrames) {
+      while (this.queueFrames[0] !== seqId) {
+        const currentSeqId = this.queueFrames[0];
+        if (this.mapFrames[currentSeqId].isDropped) {
+          framesToVisualize.push(this.mapFrames[currentSeqId]);
+        }
+        delete this.mapFrames[currentSeqId];
+        this.queueFrames.shift();
+      }
+      framesToVisualize.push(this.mapFrames[seqId]);
+      delete this.mapFrames[seqId];
+      this.queueFrames.shift();
+    }
+    return framesToVisualize;
+  }
+}
+export function framesWithinWindow(frames, startTime, endTime) {
+  const firstFrame = Platform.ArrayUtilities.lowerBound(frames, startTime || 0, (time, frame) => time - frame.endTime);
+  const lastFrame = Platform.ArrayUtilities.lowerBound(frames, endTime || Infinity, (time, frame) => time - frame.startTime);
+  return frames.slice(firstFrame, lastFrame);
+}
+//# sourceMappingURL=FramesHandler.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/FramesHandler.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 * as Platform from '../../../core/platform/platform.js';\nimport * as Helpers from '../helpers/helpers.js';\nimport * as Types from '../types/types.js';\n\nimport {type AuctionWorkletsData, data as auctionWorkletsData} from './AuctionWorkletsHandler.js';\nimport {data as layerTreeHandlerData, type LayerTreeData} from './LayerTreeHandler.js';\nimport {data as metaHandlerData, type MetaHandlerData} from './MetaHandler.js';\nimport {data as rendererHandlerData, type RendererHandlerData} from './RendererHandler.js';\nimport * as Threads from './Threads.js';\nimport {HandlerState, type TraceEventHandlerName} from './types.js';\n\n/**\n * IMPORTANT: this handler is slightly different to the rest. This is because\n * it is an adaptation of the TimelineFrameModel that has been used in DevTools\n * for many years. Rather than re-implement all the logic from scratch, instead\n * this handler gathers up the events and instantitates the class in the\n * finalize() method. Once the class has parsed all events, it is used to then\n * return the array of frames.\n *\n * In time we expect to migrate this code to a more \"typical\" handler.\n */\nlet handlerState = HandlerState.UNINITIALIZED;\n\nconst allEvents: Types.TraceEvents.TraceEventData[] = [];\nlet model: TimelineFrameModel|null = null;\n\nexport function reset(): void {\n  handlerState = HandlerState.UNINITIALIZED;\n  allEvents.length = 0;\n}\nexport function initialize(): void {\n  if (handlerState !== HandlerState.UNINITIALIZED) {\n    throw new Error('FramesHandler was not reset before being initialized');\n  }\n\n  handlerState = HandlerState.INITIALIZED;\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  allEvents.push(event);\n}\n\nexport async function finalize(): Promise<void> {\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('FramesHandler is not initialized');\n  }\n\n  // Snapshot events can be emitted out of order, so we need to sort before\n  // building the frames model.\n  Helpers.Trace.sortTraceEventsInPlace(allEvents);\n\n  const modelForTrace = new TimelineFrameModel(\n      allEvents,\n      rendererHandlerData(),\n      auctionWorkletsData(),\n      metaHandlerData(),\n      layerTreeHandlerData(),\n  );\n  model = modelForTrace;\n}\n\nexport interface FramesData {\n  frames: readonly TimelineFrame[];\n  framesById: Readonly<Record<number, TimelineFrame|undefined>>;\n}\n\nexport function data(): FramesData {\n  return {\n    frames: model ? Array.from(model.frames()) : [],\n    framesById: model ? {...model.framesById()} : {},\n  };\n}\n\nexport function deps(): TraceEventHandlerName[] {\n  return ['Meta', 'Renderer', 'AuctionWorklets', 'LayerTree'];\n}\n\ntype FrameEvent = Types.TraceEvents.TraceEventBeginFrame|Types.TraceEvents.TraceEventDroppedFrame|\n                  Types.TraceEvents.TraceEventRequestMainThreadFrame|\n                  Types.TraceEvents.TraceEventBeginMainThreadFrame|Types.TraceEvents.TraceEventCommit|\n                  Types.TraceEvents.TraceEventCompositeLayers|Types.TraceEvents.TraceEventActivateLayerTree|\n                  Types.TraceEvents.TraceEventNeedsBeginFrameChanged|Types.TraceEvents.TraceEventDrawFrame;\n\nfunction isFrameEvent(event: Types.TraceEvents.TraceEventData): event is FrameEvent {\n  return (\n      Types.TraceEvents.isTraceEventSetLayerId(event) || Types.TraceEvents.isTraceEventBeginFrame(event) ||\n      Types.TraceEvents.isTraceEventDroppedFrame(event) ||\n      Types.TraceEvents.isTraceEventRequestMainThreadFrame(event) ||\n      Types.TraceEvents.isTraceEventBeginMainThreadFrame(event) ||\n      Types.TraceEvents.isTraceEventNeedsBeginFrameChanged(event) ||\n      // Note that \"Commit\" is the replacement for \"CompositeLayers\" so in a trace\n      // we wouldn't expect to see a combination of these. All \"new\" trace\n      // recordings use \"Commit\", but we can easily support \"CompositeLayers\" too\n      // to not break older traces being imported.\n      Types.TraceEvents.isTraceEventCommit(event) || Types.TraceEvents.isTraceEventCompositeLayers(event) ||\n      Types.TraceEvents.isTraceEventActivateLayerTree(event) || Types.TraceEvents.isTraceEventDrawFrame(event));\n}\n\nfunction entryIsTopLevel(entry: Types.TraceEvents.TraceEventData): boolean {\n  const devtoolsTimelineCategory = 'disabled-by-default-devtools.timeline';\n  return entry.name === Types.TraceEvents.KnownEventName.RunTask && entry.cat.includes(devtoolsTimelineCategory);\n}\n\nexport class TimelineFrameModel {\n  #frames: TimelineFrame[] = [];\n  #frameById: {\n    [x: number]: TimelineFrame,\n  } = {};\n  #beginFrameQueue: TimelineFrameBeginFrameQueue = new TimelineFrameBeginFrameQueue();\n  #lastFrame: TimelineFrame|null = null;\n  #mainFrameCommitted = false;\n  #mainFrameRequested = false;\n  #lastLayerTree: FrameLayerTreeData|null = null;\n  #framePendingActivation: PendingFrame|null = null;\n  #framePendingCommit: PendingFrame|null = null;\n  #lastBeginFrame: number|null = null;\n  #lastNeedsBeginFrame: number|null = null;\n  #lastTaskBeginTime: Types.Timing.MicroSeconds|null = null;\n  #layerTreeId: number|null = null;\n  #activeProcessId: Types.TraceEvents.ProcessID|null = null;\n  #activeThreadId: Types.TraceEvents.ThreadID|null = null;\n  #layerTreeData: LayerTreeData;\n\n  constructor(\n      allEvents: readonly Types.TraceEvents.TraceEventData[], rendererData: RendererHandlerData,\n      auctionWorkletsData: AuctionWorkletsData, metaData: MetaHandlerData, layerTreeData: LayerTreeData) {\n    // We only care about getting threads from the Renderer, not Samples,\n    // because Frames don't exist in a CPU Profile (which won't have Renderer\n    // threads.)\n    const mainThreads = Threads.threadsInRenderer(rendererData, auctionWorkletsData).filter(thread => {\n      return thread.type === Threads.ThreadType.MAIN_THREAD && thread.processIsOnMainFrame;\n    });\n    const threadData = mainThreads.map(thread => {\n      return {\n        tid: thread.tid,\n        pid: thread.pid,\n        startTime: thread.entries[0].ts,\n      };\n    });\n\n    this.#layerTreeData = layerTreeData;\n    this.#addTraceEvents(allEvents, threadData, metaData.mainFrameId);\n  }\n\n  framesById(): Readonly<Record<number, TimelineFrame|undefined>> {\n    return this.#frameById;\n  }\n\n  frames(): TimelineFrame[] {\n    return this.#frames;\n  }\n\n  #handleBeginFrame(startTime: Types.Timing.MicroSeconds, seqId: number): void {\n    if (!this.#lastFrame) {\n      this.#startFrame(startTime, seqId);\n    }\n    this.#lastBeginFrame = startTime;\n\n    this.#beginFrameQueue.addFrameIfNotExists(seqId, startTime, false, false);\n  }\n\n  #handleDroppedFrame(startTime: Types.Timing.MicroSeconds, seqId: number, isPartial: boolean): void {\n    if (!this.#lastFrame) {\n      this.#startFrame(startTime, seqId);\n    }\n\n    // This line handles the case where no BeginFrame event is issued for\n    // the dropped frame. In this situation, add a BeginFrame to the queue\n    // as if it actually occurred.\n    this.#beginFrameQueue.addFrameIfNotExists(seqId, startTime, true, isPartial);\n    this.#beginFrameQueue.setDropped(seqId, true);\n    this.#beginFrameQueue.setPartial(seqId, isPartial);\n  }\n\n  #handleDrawFrame(startTime: Types.Timing.MicroSeconds, seqId: number): void {\n    if (!this.#lastFrame) {\n      this.#startFrame(startTime, seqId);\n      return;\n    }\n\n    // - if it wasn't drawn, it didn't happen!\n    // - only show frames that either did not wait for the main thread frame or had one committed.\n    if (this.#mainFrameCommitted || !this.#mainFrameRequested) {\n      if (this.#lastNeedsBeginFrame) {\n        const idleTimeEnd = this.#framePendingActivation ? this.#framePendingActivation.triggerTime :\n                                                           (this.#lastBeginFrame || this.#lastNeedsBeginFrame);\n        if (idleTimeEnd > this.#lastFrame.startTime) {\n          this.#lastFrame.idle = true;\n          this.#lastBeginFrame = null;\n        }\n        this.#lastNeedsBeginFrame = null;\n      }\n\n      const framesToVisualize = this.#beginFrameQueue.processPendingBeginFramesOnDrawFrame(seqId);\n\n      // Visualize the current frame and all pending frames before it.\n      for (const frame of framesToVisualize) {\n        const isLastFrameIdle = this.#lastFrame.idle;\n\n        // If |frame| is the first frame after an idle period, the CPU time\n        // will be logged (\"committed\") under |frame| if applicable.\n        this.#startFrame(frame.startTime, seqId);\n        if (isLastFrameIdle && this.#framePendingActivation) {\n          this.#commitPendingFrame();\n        }\n        if (frame.isDropped) {\n          this.#lastFrame.dropped = true;\n        }\n        if (frame.isPartial) {\n          this.#lastFrame.isPartial = true;\n        }\n      }\n    }\n    this.#mainFrameCommitted = false;\n  }\n\n  #handleActivateLayerTree(): void {\n    if (!this.#lastFrame) {\n      return;\n    }\n    if (this.#framePendingActivation && !this.#lastNeedsBeginFrame) {\n      this.#commitPendingFrame();\n    }\n  }\n\n  #handleRequestMainThreadFrame(): void {\n    if (!this.#lastFrame) {\n      return;\n    }\n    this.#mainFrameRequested = true;\n  }\n\n  #handleCommit(): void {\n    if (!this.#framePendingCommit) {\n      return;\n    }\n    this.#framePendingActivation = this.#framePendingCommit;\n    this.#framePendingCommit = null;\n    this.#mainFrameRequested = false;\n    this.#mainFrameCommitted = true;\n  }\n\n  #handleLayerTreeSnapshot(layerTree: FrameLayerTreeData): void {\n    this.#lastLayerTree = layerTree;\n  }\n\n  #handleNeedFrameChanged(startTime: Types.Timing.MicroSeconds, needsBeginFrame: boolean): void {\n    if (needsBeginFrame) {\n      this.#lastNeedsBeginFrame = startTime;\n    }\n  }\n\n  #startFrame(startTime: Types.Timing.MicroSeconds, seqId: number): void {\n    if (this.#lastFrame) {\n      this.#flushFrame(this.#lastFrame, startTime);\n    }\n    this.#lastFrame =\n        new TimelineFrame(seqId, startTime, Types.Timing.MicroSeconds(startTime - metaHandlerData().traceBounds.min));\n  }\n\n  #flushFrame(frame: TimelineFrame, endTime: Types.Timing.MicroSeconds): void {\n    frame.setLayerTree(this.#lastLayerTree);\n    frame.setEndTime(endTime);\n    if (this.#lastLayerTree) {\n      this.#lastLayerTree.paints = frame.paints;\n    }\n    const lastFrame = this.#frames[this.#frames.length - 1];\n    if (this.#frames.length && lastFrame &&\n        (frame.startTime !== lastFrame.endTime || frame.startTime > frame.endTime)) {\n      console.assert(\n          false, `Inconsistent frame time for frame ${this.#frames.length} (${frame.startTime} - ${frame.endTime})`);\n    }\n    this.#frames.push(frame);\n    if (typeof frame.mainFrameId === 'number') {\n      this.#frameById[frame.mainFrameId] = frame;\n    }\n  }\n\n  #commitPendingFrame(): void {\n    if (!this.#framePendingActivation || !this.#lastFrame) {\n      return;\n    }\n\n    this.#lastFrame.paints = this.#framePendingActivation.paints;\n    this.#lastFrame.mainFrameId = this.#framePendingActivation.mainFrameId;\n    this.#framePendingActivation = null;\n  }\n\n  #addTraceEvents(\n      events: readonly Types.TraceEvents.TraceEventData[], threadData: {\n        pid: Types.TraceEvents.ProcessID,\n        tid: Types.TraceEvents.ThreadID,\n        startTime: Types.Timing.MicroSeconds,\n      }[],\n      mainFrameId: string): void {\n    let j = 0;\n    this.#activeThreadId = threadData.length && threadData[0].tid || null;\n    this.#activeProcessId = threadData.length && threadData[0].pid || null;\n    for (let i = 0; i < events.length; ++i) {\n      while (j + 1 < threadData.length && threadData[j + 1].startTime <= events[i].ts) {\n        this.#activeThreadId = threadData[++j].tid;\n        this.#activeProcessId = threadData[j].pid;\n      }\n      this.#addTraceEvent(events[i], mainFrameId);\n    }\n    this.#activeThreadId = null;\n    this.#activeProcessId = null;\n  }\n\n  #addTraceEvent(event: Types.TraceEvents.TraceEventData, mainFrameId: string): void {\n    if (Types.TraceEvents.isTraceEventSetLayerId(event) && event.args.data.frame === mainFrameId) {\n      this.#layerTreeId = event.args.data.layerTreeId;\n    } else if (\n        Types.TraceEvents.isTraceEventLayerTreeHostImplSnapshot(event) && Number(event.id) === this.#layerTreeId) {\n      this.#handleLayerTreeSnapshot({\n        entry: event,\n        paints: [],\n      });\n    } else {\n      if (isFrameEvent(event)) {\n        this.#processCompositorEvents(event);\n      }\n      // Make sure we only use events from the main thread: we check the PID as\n      // well in case two processes have a thread with the same TID.\n      if (event.tid === this.#activeThreadId && event.pid === this.#activeProcessId) {\n        this.#addMainThreadTraceEvent(event);\n      }\n    }\n  }\n\n  #processCompositorEvents(entry: FrameEvent): void {\n    if (entry.args['layerTreeId'] !== this.#layerTreeId) {\n      return;\n    }\n    if (Types.TraceEvents.isTraceEventBeginFrame(entry)) {\n      this.#handleBeginFrame(entry.ts, entry.args['frameSeqId']);\n    } else if (Types.TraceEvents.isTraceEventDrawFrame(entry)) {\n      this.#handleDrawFrame(entry.ts, entry.args['frameSeqId']);\n    } else if (Types.TraceEvents.isTraceEventActivateLayerTree(entry)) {\n      this.#handleActivateLayerTree();\n    } else if (Types.TraceEvents.isTraceEventRequestMainThreadFrame(entry)) {\n      this.#handleRequestMainThreadFrame();\n    } else if (Types.TraceEvents.isTraceEventNeedsBeginFrameChanged(entry)) {\n      // needsBeginFrame property will either be 0 or 1, which represents\n      // true/false in this case, hence the Boolean() wrapper.\n      this.#handleNeedFrameChanged(entry.ts, entry.args['data'] && Boolean(entry.args['data']['needsBeginFrame']));\n    } else if (Types.TraceEvents.isTraceEventDroppedFrame(entry)) {\n      this.#handleDroppedFrame(entry.ts, entry.args['frameSeqId'], Boolean(entry.args['hasPartialUpdate']));\n    }\n  }\n\n  #addMainThreadTraceEvent(entry: Types.TraceEvents.TraceEventData): void {\n    if (entryIsTopLevel(entry)) {\n      this.#lastTaskBeginTime = entry.ts;\n    }\n    if (!this.#framePendingCommit && MAIN_FRAME_MARKERS.has(entry.name as Types.TraceEvents.KnownEventName)) {\n      this.#framePendingCommit = new PendingFrame(this.#lastTaskBeginTime || entry.ts);\n    }\n    if (!this.#framePendingCommit) {\n      return;\n    }\n\n    if (Types.TraceEvents.isTraceEventBeginMainThreadFrame(entry) && entry.args.data.frameId) {\n      this.#framePendingCommit.mainFrameId = entry.args.data.frameId;\n    }\n    if (Types.TraceEvents.isTraceEventPaint(entry)) {\n      const snapshot = this.#layerTreeData.paintsToSnapshots.get(entry);\n      if (snapshot) {\n        this.#framePendingCommit.paints.push(new LayerPaintEvent(entry, snapshot));\n      }\n    }\n    // Commit will be replacing CompositeLayers but CompositeLayers is kept\n    // around for backwards compatibility.\n    if ((Types.TraceEvents.isTraceEventCompositeLayers(entry) || Types.TraceEvents.isTraceEventCommit(entry)) &&\n        entry.args['layerTreeId'] === this.#layerTreeId) {\n      this.#handleCommit();\n    }\n  }\n}\n\nconst MAIN_FRAME_MARKERS = new Set<Types.TraceEvents.KnownEventName>([\n  Types.TraceEvents.KnownEventName.ScheduleStyleRecalculation,\n  Types.TraceEvents.KnownEventName.InvalidateLayout,\n  Types.TraceEvents.KnownEventName.BeginMainThreadFrame,\n  Types.TraceEvents.KnownEventName.ScrollLayer,\n]);\n\nexport interface FrameLayerTreeData {\n  entry: Types.TraceEvents.TraceEventLayerTreeHostImplSnapshot;\n  paints: LayerPaintEvent[];\n}\n\nexport class TimelineFrame {\n  startTime: Types.Timing.MicroSeconds;\n  startTimeOffset: Types.Timing.MicroSeconds;\n  endTime: Types.Timing.MicroSeconds;\n  duration: Types.Timing.MicroSeconds;\n  idle: boolean;\n  dropped: boolean;\n  isPartial: boolean;\n  layerTree: FrameLayerTreeData|null;\n  paints: LayerPaintEvent[];\n  mainFrameId: number|undefined;\n  readonly seqId: number;\n\n  constructor(seqId: number, startTime: Types.Timing.MicroSeconds, startTimeOffset: Types.Timing.MicroSeconds) {\n    this.seqId = seqId;\n    this.startTime = startTime;\n    this.startTimeOffset = startTimeOffset;\n    this.endTime = this.startTime;\n    this.duration = Types.Timing.MicroSeconds(0);\n    this.idle = false;\n    this.dropped = false;\n    this.isPartial = false;\n    this.layerTree = null;\n    this.paints = [];\n    this.mainFrameId = undefined;\n  }\n\n  setEndTime(endTime: Types.Timing.MicroSeconds): void {\n    this.endTime = endTime;\n    this.duration = Types.Timing.MicroSeconds(this.endTime - this.startTime);\n  }\n\n  setLayerTree(layerTree: FrameLayerTreeData|null): void {\n    this.layerTree = layerTree;\n  }\n}\n\nexport interface LayerPaintEventPicture {\n  rect: Array<number>;\n  serializedPicture: string;\n}\nexport class LayerPaintEvent {\n  readonly #event: Types.TraceEvents.TraceEventPaint;\n  #snapshot: Types.TraceEvents.TraceEventDisplayItemListSnapshot;\n\n  constructor(event: Types.TraceEvents.TraceEventPaint, snapshot: Types.TraceEvents.TraceEventDisplayItemListSnapshot) {\n    this.#event = event;\n    this.#snapshot = snapshot;\n  }\n\n  layerId(): number {\n    return this.#event.args.data.layerId;\n  }\n\n  event(): Types.TraceEvents.TraceEventPaint {\n    return this.#event;\n  }\n\n  picture(): LayerPaintEventPicture|null {\n    const rect = this.#snapshot.args.snapshot.params?.layer_rect;\n    const pictureData = this.#snapshot.args.snapshot.skp64;\n    return rect && pictureData ? {rect: rect, serializedPicture: pictureData} : null;\n  }\n}\n\nexport class PendingFrame {\n  paints: LayerPaintEvent[];\n  mainFrameId: number|undefined;\n  triggerTime: number;\n  constructor(triggerTime: number) {\n    this.paints = [];\n    this.mainFrameId = undefined;\n    this.triggerTime = triggerTime;\n  }\n}\n\n// The parameters of an impl-side BeginFrame.\nclass BeginFrameInfo {\n  seqId: number;\n  startTime: Types.Timing.MicroSeconds;\n  isDropped: boolean;\n  isPartial: boolean;\n  constructor(seqId: number, startTime: Types.Timing.MicroSeconds, isDropped: boolean, isPartial: boolean) {\n    this.seqId = seqId;\n    this.startTime = startTime;\n    this.isDropped = isDropped;\n    this.isPartial = isPartial;\n  }\n}\n\n// A queue of BeginFrames pending visualization.\n// BeginFrames are added into this queue as they occur; later when their\n// corresponding DrawFrames occur (or lack thereof), the BeginFrames are removed\n// from the queue and their timestamps are used for visualization.\nexport class TimelineFrameBeginFrameQueue {\n  private queueFrames: number[] = [];\n\n  // Maps frameSeqId to BeginFrameInfo.\n  private mapFrames: {\n    [x: number]: BeginFrameInfo,\n  } = {};\n\n  // Add a BeginFrame to the queue, if it does not already exit.\n  addFrameIfNotExists(seqId: number, startTime: Types.Timing.MicroSeconds, isDropped: boolean, isPartial: boolean):\n      void {\n    if (!(seqId in this.mapFrames)) {\n      this.mapFrames[seqId] = new BeginFrameInfo(seqId, startTime, isDropped, isPartial);\n      this.queueFrames.push(seqId);\n    }\n  }\n\n  // Set a BeginFrame in queue as dropped.\n  setDropped(seqId: number, isDropped: boolean): void {\n    if (seqId in this.mapFrames) {\n      this.mapFrames[seqId].isDropped = isDropped;\n    }\n  }\n\n  setPartial(seqId: number, isPartial: boolean): void {\n    if (seqId in this.mapFrames) {\n      this.mapFrames[seqId].isPartial = isPartial;\n    }\n  }\n\n  processPendingBeginFramesOnDrawFrame(seqId: number): BeginFrameInfo[] {\n    const framesToVisualize: BeginFrameInfo[] = [];\n\n    // Do not visualize this frame in the rare case where the current DrawFrame\n    // does not have a corresponding BeginFrame.\n    if (seqId in this.mapFrames) {\n      // Pop all BeginFrames before the current frame, and add only the dropped\n      // ones in |frames_to_visualize|.\n      // Non-dropped frames popped here are BeginFrames that are never\n      // drawn (but not considered dropped either for some reason).\n      // Those frames do not require an proactive visualization effort and will\n      // be naturally presented as continuationss of other frames.\n      while (this.queueFrames[0] !== seqId) {\n        const currentSeqId = this.queueFrames[0];\n        if (this.mapFrames[currentSeqId].isDropped) {\n          framesToVisualize.push(this.mapFrames[currentSeqId]);\n        }\n\n        delete this.mapFrames[currentSeqId];\n        this.queueFrames.shift();\n      }\n\n      // Pop the BeginFrame associated with the current DrawFrame.\n      framesToVisualize.push(this.mapFrames[seqId]);\n      delete this.mapFrames[seqId];\n      this.queueFrames.shift();\n    }\n    return framesToVisualize;\n  }\n}\n\nexport function framesWithinWindow(\n    frames: readonly TimelineFrame[], startTime: Types.Timing.MicroSeconds,\n    endTime: Types.Timing.MicroSeconds): TimelineFrame[] {\n  const firstFrame = Platform.ArrayUtilities.lowerBound(frames, startTime || 0, (time, frame) => time - frame.endTime);\n  const lastFrame =\n      Platform.ArrayUtilities.lowerBound(frames, endTime || Infinity, (time, frame) => time - frame.startTime);\n  return frames.slice(firstFrame, lastFrame);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/handlers/GPUHandler.js

@@ -0,0 +1,50 @@
+import { data as metaHandlerData } from "./MetaHandler.js";
+import { HandlerState } from "./types.js";
+import * as Types from "../types/types.js";
+import * as Helpers from "../helpers/helpers.js";
+let handlerState = HandlerState.UNINITIALIZED;
+const eventsInProcessThread = /* @__PURE__ */ new Map();
+let mainGPUThreadTasks = [];
+export function reset() {
+  eventsInProcessThread.clear();
+  mainGPUThreadTasks = [];
+  handlerState = HandlerState.UNINITIALIZED;
+}
+export function initialize() {
+  if (handlerState !== HandlerState.UNINITIALIZED) {
+    throw new Error("GPU Handler was not reset before being initialized");
+  }
+  handlerState = HandlerState.INITIALIZED;
+}
+export function handleEvent(event) {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("GPU Handler is not initialized");
+  }
+  if (!Types.TraceEvents.isTraceEventGPUTask(event)) {
+    return;
+  }
+  Helpers.Trace.addEventToProcessThread(event, eventsInProcessThread);
+}
+export async function finalize() {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("GPU Handler is not initialized");
+  }
+  const { gpuProcessId, gpuThreadId } = metaHandlerData();
+  const gpuThreadsForProcess = eventsInProcessThread.get(gpuProcessId);
+  if (gpuThreadsForProcess && gpuThreadId) {
+    mainGPUThreadTasks = gpuThreadsForProcess.get(gpuThreadId) || [];
+  }
+  handlerState = HandlerState.FINALIZED;
+}
+export function data() {
+  if (handlerState !== HandlerState.FINALIZED) {
+    throw new Error("GPU Handler is not finalized");
+  }
+  return {
+    mainGPUThreadTasks: [...mainGPUThreadTasks]
+  };
+}
+export function deps() {
+  return ["Meta"];
+}
+//# sourceMappingURL=GPUHandler.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/GPUHandler.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 {data as metaHandlerData} from './MetaHandler.js';\n\nimport {type TraceEventHandlerName, HandlerState} from './types.js';\n\nimport * as Types from '../types/types.js';\nimport * as Helpers from '../helpers/helpers.js';\n\nlet handlerState = HandlerState.UNINITIALIZED;\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 eventsInProcessThread =\n    new Map<Types.TraceEvents.ProcessID, Map<Types.TraceEvents.ThreadID, Types.TraceEvents.TraceEventGPUTask[]>>();\n\nlet mainGPUThreadTasks: Types.TraceEvents.TraceEventGPUTask[] = [];\n\nexport function reset(): void {\n  eventsInProcessThread.clear();\n  mainGPUThreadTasks = [];\n\n  handlerState = HandlerState.UNINITIALIZED;\n}\n\nexport function initialize(): void {\n  if (handlerState !== HandlerState.UNINITIALIZED) {\n    throw new Error('GPU Handler was not reset before being initialized');\n  }\n\n  handlerState = HandlerState.INITIALIZED;\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('GPU Handler is not initialized');\n  }\n\n  if (!Types.TraceEvents.isTraceEventGPUTask(event)) {\n    return;\n  }\n\n  Helpers.Trace.addEventToProcessThread(event, eventsInProcessThread);\n}\n\nexport async function finalize(): Promise<void> {\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('GPU Handler is not initialized');\n  }\n\n  const {gpuProcessId, gpuThreadId} = metaHandlerData();\n  const gpuThreadsForProcess = eventsInProcessThread.get(gpuProcessId);\n  if (gpuThreadsForProcess && gpuThreadId) {\n    mainGPUThreadTasks = gpuThreadsForProcess.get(gpuThreadId) || [];\n  }\n  handlerState = HandlerState.FINALIZED;\n}\n\nexport interface GPUHandlerReturnData {\n  mainGPUThreadTasks: readonly Types.TraceEvents.TraceEventGPUTask[];\n}\n\nexport function data(): GPUHandlerReturnData {\n  if (handlerState !== HandlerState.FINALIZED) {\n    throw new Error('GPU Handler is not finalized');\n  }\n  return {\n    mainGPUThreadTasks: [...mainGPUThreadTasks],\n  };\n}\n\nexport function deps(): TraceEventHandlerName[] {\n  return ['Meta'];\n}\n"],
+  "mappings": "AAIA;AAEA;AAEA;AACA;AAEA,IAAI,eAAe,aAAa;AAIhC,MAAM,wBACF,oBAAI;AAER,IAAI,qBAA4D;AAEzD,wBAAuB;AAC5B,wBAAsB;AACtB,uBAAqB;AAErB,iBAAe,aAAa;AAAA;AAGvB,6BAA4B;AACjC,MAAI,iBAAiB,aAAa,eAAe;AAC/C,UAAM,IAAI,MAAM;AAAA;AAGlB,iBAAe,aAAa;AAAA;AAGvB,4BAAqB,OAA+C;AACzE,MAAI,iBAAiB,aAAa,aAAa;AAC7C,UAAM,IAAI,MAAM;AAAA;AAGlB,MAAI,CAAC,MAAM,YAAY,oBAAoB,QAAQ;AACjD;AAAA;AAGF,UAAQ,MAAM,wBAAwB,OAAO;AAAA;AAG/C,iCAAgD;AAC9C,MAAI,iBAAiB,aAAa,aAAa;AAC7C,UAAM,IAAI,MAAM;AAAA;AAGlB,QAAM,EAAC,cAAc,gBAAe;AACpC,QAAM,uBAAuB,sBAAsB,IAAI;AACvD,MAAI,wBAAwB,aAAa;AACvC,yBAAqB,qBAAqB,IAAI,gBAAgB;AAAA;AAEhE,iBAAe,aAAa;AAAA;AAOvB,uBAAsC;AAC3C,MAAI,iBAAiB,aAAa,WAAW;AAC3C,UAAM,IAAI,MAAM;AAAA;AAElB,SAAO;AAAA,IACL,oBAAoB,CAAC,GAAG;AAAA;AAAA;AAIrB,uBAAyC;AAC9C,SAAO,CAAC;AAAA;",
+  "names": []
+}