zezeozue

ui: Encapsulate plugin state in HeapDumpExplorerSession (#5679) The plugin's mutable state was scattered across module-level let/const variables, static fields on HeapDumpPage, and the dumps/activeDump/bitmap-cache globals in queries.ts, with implicit reset semantics. Concentrate it on a session class constructed per onTraceLoad: the session owns nav, dumps, tabs, and the cached overview, and is registered with the page via ctx.pages.registerPage so it's captured by closure and disposed with the trace.

tp: android.display.video data source, importer, table and stats (#6143) Adds trace_processor support for the android.display.video data source, which captures device display frames as a hardware video elementary stream. Wire format (protos/perfetto/trace/android/video_frame.proto): * VideoFrame (TracePacket.video_frame): a codec_config-only frame per stream (carrying display_name + RFC 6381 codec_string), then one VideoFrame per on-screen change with a single access unit (au_data). Self-identifying via a per-session display_id. * VideoFrameError (TracePacket.video_frame_error): per-stream failure with a Reason enum (size cap hit, codec error, display gone, no encoder, display not found, encoder setup failed, virtual display failed). Config: DataSourceConfig.display_video_config. Importer (src/trace_processor/plugins/video_frame_importer/): * Parses video_frame into the __intrinsic_video_frames table. The encoded payload is stored zero-copy as a TraceBlobView, surfaced via the __INTRINSIC_VIDEO_FRAME_AU_DATA(id) scalar function (same pattern HPROF/ETM use for blob payloads). * Maps each VideoFrameError reason to its own kIndexed entry in the global stats table, keyed by display_id. * Enforces a parse-time 256 MB per-stream cap as a backstop against traces recorded without a producer cap: over-cap frames are dropped and android_video_size_cap_hit is reported once. The table is intrinsic (not a stdlib module) since only the VideoFrames UI consumes it. Tests: diff tests (single/multi display, au_data blob equivalence, all VideoFrameError reasons) and a unit test for the parse-time cap.

ui: VideoFrames plugin (#6155) Adds the dev.perfetto.VideoFrames plugin for the android.display.video data source: a per-display video-frame track, a WebCodecs player (decode + playback), a details panel and a selection tab. Reads the trace_processor surface by name (__intrinsic_video_frames + __intrinsic_video_frame_au_data). The plugin is disabled by default

tp: add (pid)/(tid) field options and annotate frameworks_base (#6756) Adds two custom field options (in field_options.proto) for integer fields that hold OS ids: - (perfetto.protos.pid): the field is a process id. Alongside the raw value, trace_processor emits two extra args keyed by replacing the trailing "pid": "<name>upid" (the trace-unique upid) and "<name>process_name". e.g. caller_pid -> caller_upid + caller_process_name. - (perfetto.protos.tid): the same for thread ids, emitting "<name>utid" and "<name>thread_name". The upid/utid come from GetProcessOrNull/GetThreadOrNull, which are plain lookups: if the pid/tid was never seen, no extra arg is emitted and no process/thread is created. Also annotates the pid, caller_pid, sender_pid and receiver_pid fields in frameworks_base_track_event.proto.

ui: Persist Heap Dump Explorer state in shared links (#6115) The Heap Dump Explorer kept its state (selected dump, active tab, open flamegraph and instance drill-down tabs, and the main flamegraph's filter/pivot/view state) in a per-trace session object rebuilt from scratch on every load, so a shared permalink dropped all of it and always reopened on the overview. Mirror the session state into a plugin store via ctx.mountStore(), which the core serializes into the permalink and restores before the plugin runs. On load the session rehydrates from the store (keyed on the heap dump still existing in the trace)

android_sdk: Add nested-track ordering and merging (#6262) Expose sibling ordering and sibling merging for nested tracks end to end, from the C SDK high-level ABI through te_macros, the shared lib, JNI and the Android Java SDK. - PerfettoTeHlNestedTrackNamed gains sibling_order_rank, child_ordering, sibling_merge_behavior and a string/integer sibling merge key, with PERFETTO_TE_HL_CHILD_ORDERING_* and PERFETTO_TE_HL_SIBLING_MERGE_BEHAVIOR_* constants mirroring the proto enums. - te_macros: PERFETTO_TE_NESTED_TRACK_NAMED_ORDERED(NAME, ID, RANK, ORDERING) and PERFETTO_TE_NESTED_TRACK_NAMED_MERGED(NAME, ID, BEHAVIOR, KEY_STR, KEY_INT). - hl.cc: EmitNamedTrack now takes the nested-named struct and emits the new fields on the TrackDescriptor. - Java: PerfettoTrack.setSiblingOrderRank() / setChildOrdering() / setSiblingMergeBehavior() / setSiblingMergeKey(long|String) plus CHILD_ORDERING_* and SIBLING_MERGE_BEHAVIOR_* constants; the chain carries parallel arrays through JNI (direct region copies, lengths validated against the names array). Rust bindings mirror the struct additions. The example, shared-lib integration tests and Java host tests cover both features.

sdk: add state track event support (C HL API + Java SDK) (#6464) Adds first-class support for TYPE_STATE track events: a "symbolic counter" whose value over time is a label rather than a number (empty value = idle). The state value is carried in the event name. C HL API (mirrors the counter API): - PERFETTO_TE_TYPE_STATE and its EventType() mapping. - PerfettoTeStateTrack{Uuid,FillDesc,Register} to declare a state track. - PERFETTO_TE_STATE(value) / PERFETTO_TE_STATE_TRACK(name, parent) macros. Java SDK (mirrors the counter API): - PerfettoTrace.state(category, value, trackName). - Builder usingStateTrack / usingProcessStateTrack, a StateTrack extra, and its JNI binding (RegisteredTrack gains a state path).

ui: Disambiguate multi-dump traces in the Heap Dump Explorer (#5631) Add a dump selector so traces with multiple heap dumps filter all views to a single (upid, ts) pair instead of silently summing across dumps.

android_sdk: add nested tracks (#6085) Immutable PerfettoTrack handle (process/thread/global root + child()) plus usingTrack(), carried by one native NestedTracks extra over the existing HL NESTED_TRACKS ABI. Example usage: static final PerfettoTrack RENDER = PerfettoTrack.process("Render"); static final PerfettoTrack GPU = RENDER.child("GPU"); PerfettoTrace.instant(CAT, "frame").usingTrack(GPU).emit(); Updated the abi to expose a static name option for PerfettoTeHlNestedTrackNamed

ui: Extract FlamegraphPanel widget from QueryFlamegraph (#5730) Mithril component that owns the inner QueryFlamegraph and disposes it on unmount or when trace/dependencies identity changes. Migrates all consumers and drops QueryFlamegraphWithMetrics. Also adds optional `displayLabel` on the PIVOT view; SQL match still uses `pivot`. This will be used in the future by the HeapDumpExplorer to provide a better UX when it auto filters a flamegraph to path hash

tp: android_framework_track_event plugin + process lifecycle table (#6364) Recorded the frameworks/base AndroidProcessStartEvent and AndroidBinderDiedEvent TrackEvent extensions into a new __intrinsic_android_track_event_process table (upid, fw_start_ts, fw_end_ts): Built on the TrackEvent extension plugin API: AndroidFrameworkTrackEventPlugin extends TrackEventPlugin, owns the two extension field ids, and reacts at the args level off the inserted SliceId (returns kIgnored, so the events are still flattened into args). Also dropped the aliased IMPORTANCE_BACKGROUND enumerator from frameworks_base_track_event.proto which was redundant and deprecated.

ui: Embed flamegraph viewer in Heap Dump Explorer (#5731) Added a Flamegraph tab using FlamegraphPanel and Bidirectional navigation between object info and the flamegraph. A "Show objects from this class" node action opens the flamegraph-objects tab, and each retention-path section in the object view ("Shortest Path", "Dominator Tree Path") gets a "View in Flamegraph" button that pivots the flamegraph at the object's path.

tp: expand (flags_enum)-annotated fields into per-flag args (#6472) Adds DescriptorPool::FlagSetToViews, which expands a flag bitmask into the names of its set flags, appended as string_views into the pool's enum-name storage. Composite (multi-bit) values are skipped; the set bits with no single-bit name are returned to the caller. A proto int field can carry a (flags_enum) FieldOptions annotation naming its flags enum. proto_to_args_parser reads it and emits one string arg per set flag via FlagSetToViews, instead of the raw int. Living in the args funnel, it covers base fields and both extension surfaces with no per-parser code. The annotation is surfaced on FieldDescriptor, extracted from the field options during descriptor finalization.

tp: bounded-window walk for critical path; drop slice_name from join (#5704) The prior `_critical_path_intervals!()` pipeline iterated wakeup-graph edges with a `lead(ts)` flatten that only bounded frames by the root's window. On chains where a waker's run was shorter than the root's wait, the uncovered tail was either dropped or attributed to a thread that was itself sleeping during the window. On monitor-contention traces this showed up as runaway depth. Replace it with `__intrinsic_critical_path_walk`, a C++ intrinsic that performs a per-root recursive walk. Each frame is clipped to `[ts - idle_dur, ts + dur]`; the idle portion chains via `waker_id` (or `prev_id` on userspace IRQ self-wakes); and the time before a frame's own idle started recurses into `prev_id` at the same depth. Termination is structural - each step strictly reduces the window's upper bound - with a per-root iteration cap as a safety belt. Exposed via `_critical_path_userspace_by_roots!` and `_critical_path_kernel_by_roots!`. `_critical_path_by_roots` dispatches through them. IRQ self-wake and kernel chain semantics are preserved. Separately, drop `slice_name` from the materialized `_critical_path_thread_state_slice` and `_self_view`. Join `slice` on id at the leaves of `_critical_path_stack` instead. The TEXT was duplicated across every row of the blocker x slice cross product on large traces. Three critical-path diff-test expectations updated to drop rows that the lead-flatten attributed to idle frames.

android_sdk: add track event correlation ids (#6276) Expose track event correlation ids end to end, from the C SDK high-level ABI through te_macros, the shared lib, JNI and the Android Java SDK. - New HL extras PERFETTO_TE_HL_EXTRA_TYPE_CORRELATION_ID (uint64) and _CORRELATION_ID_STR (cstr), emitted into TrackEvent's correlation_id / correlation_id_str; te_macros PERFETTO_TE_CORRELATION_ID() and PERFETTO_TE_CORRELATION_ID_STR(). - Java: PerfettoTrackEventBuilder.setCorrelationId(long|String) via a per-builder lazily created CorrelationId extra (like Counter). Rust bindings mirror the struct additions. The example, shared-lib integration tests and Java host tests cover both variants.

ui: Show tooltips on the HeapDumpExplorer columns (#5757) Added hover info icons on the size/count columns across HDE views to surface the dominator-vs-BFS distinction. Also cleaned up the general information card with more useful info like process name and class counts.

tools: add trace_video_conv.py to extract display-video to mp4 (#6777) Reads the android.display.video frames from a trace via the trace_processor python API and muxes them into an .mp4 with ffmpeg: list the video streams, convert the whole video, clip to a time range or a SQL-selected region, change playback speed, and lay two traces' videos side by side (captioned) to compare them. Documents it in the Screen Recording data-source page.

android_sdk: host stubs for perfetto_trace_lib_java host build (#5967) Fix-forward for the host_supported flip on perfetto_trace_lib_java_defaults (landed as ca68af800e, reverted shortly after because the host build broke). The host variant of perfetto_trace_lib_framework_java fails javac with "cannot find symbol" for dalvik.annotation.optimization.CriticalNative, @FastNative, and android.system.SystemCleaner. Those classes live on the device platform classpath but aren't surfaced by Soong's host module_current. Provide a small host-only stubs library that supplies just the surface the SDK references; reference it via target.host.libs on perfetto_trace_lib_java_defaults so it's visible to javac on host but inert (and unbundled) on Android. Stub surface: * dalvik.annotation.optimization.{Critical,Fast}Native: no-op annotations; ART's specialised ABI is already handled C-side by PERFETTO_JNI_HOST_PARAMS. * android.system.SystemCleaner: delegates to java.lang.ref.Cleaner. * android.util.ArraySet: extends java.util.HashSet. * android.util.Log: routes to System.err. * android.os.Process: minimal surface the SDK references. Generator changes are limited to teaching Target about a Java-side libs field and emitting it in to_string; existing cc consumers are unaffected. The stubs library is hand-defined in Android.bp.extras as a java_library_host so it only builds on host and never lands on the Android side. With this in place, host_supported on perfetto_trace_lib_java_defaults compiles cleanly on AOSP. Tested with m out/soong/.intermediates/external/perfetto/perfetto_trace_lib_framework_java/linux_glibc_common/javac/perfetto_trace_lib_framework_java.jar

ui: show OOME heap-dump metadata as a key-value grid (#6865) Render the OutOfMemoryError summary shown above the heap-dump callstack flamegraph as a Property/Value grid (allocation size, free until OOM, and the raw error message) instead of just the raw string. The same grid is reused in the HeapProfile details panel, the Heap Dump Explorer callstack page, and a new "Out of Memory Error" section in the overview

android_sdk: PERFETTO_JNI_HOST_PARAMS shim for non-ART JVMs (#5924) @CriticalNative natives skip JNIEnv*/jclass on ART but not on host VMs. Add a PERFETTO_JNI_HOST_PARAMS[_COMMA] shim that expands to empty on Android and to JNIEnv*, jclass[,] elsewhere, and apply it to every @CriticalNative C entry point. No change in behavior. Unblocks Ravenwood: host VMs can now bind these natives directly, which lets us drop the Ravenwood native-method allowlist as a follow-up. This also enables adding a host build of the Perfetto Java SDK.