ui: add Heap Dump Explorer diff feature with palette-modulated flamegraph

Adds a baseline-vs-current diff mode to the Heap Dump Explorer with
per-tab diff views (Overview, Classes, Objects, Dominators, Bitmaps,
Strings, Arrays) and a same-trace flamegraph diff that paints each
node by Δ direction *while preserving the standard per-name palette
hue* — grew nodes saturate and darken, shrunk nodes lighten and
desaturate towards the background, unchanged nodes stay neutral, and
new nodes pop with a small saturation boost. The natural pprof-style
palette is intact so users see colour continuity between diff and
non-diff modes.
Both same-trace (two heap_graph snapshots in one .pftrace) and
cross-trace (separate primary + baseline .hprof or .pftrace files)
workflows are supported.

Changes vs. the upstream heap_diff branch (zezeozue/heap_diff):

- Fix engine-identity comparison in heap_dump_page.ts and
  baseline/state.ts. Trace.engine returns a fresh per-access proxy via
  createTraceProxy, so `getActiveBaseline()?.trace.engine === engine`
  is always false and the same-trace flamegraph diff path never fired.
  Use the stable `disposable === false` flag instead.
- Update header.ts to the new SegmentedButtons children-based API
  (selectedValue + SegmentedButton vnodes) — the upstream branch was
  written against the old `options:` prop and produced a runtime
  error.
- Replace the absolute hsl(0, ...) / hsl(220, ...) red/blue diff
  colouring with palette-modulated colours so each class keeps its
  natural pprof-style hue and we only modulate saturation/lightness
  to encode direction. Implemented in
  ui/src/widgets/flamegraph.ts (new modulatePaletteScheme helper +
  extended getColorSchemeFromHint signature) with the SQL emitting
  'palette:DIR[:INTENSITY]' hints.
- Add tools/heap_dump_diff_test_app/HeapDumpDiffTest.java: a real
  Java app that builds a deep, branchy Android-app-shaped object
  graph (Application → ActivityManager → Activity → … → byte[]) and
  captures two .hprof snapshots via HotSpotDiagnosticMXBean.dumpHeap
  for the cross-trace diff workflow.
- Add tools/heap_dump_diff_test_app/build_rich_fixture.py: textproto
  generator for the synthetic two-snapshot fixture used by the
  same-trace flamegraph diff test.
- Add docs/heap_diff/{README.md,screenshots/}: end-to-end screenshots
  of every diff tab and the primary-dump popup, captured against the
  rich fixture and against real JVM hprofs (cross-trace screenshots
  under cross_trace/).

Rebased onto current upstream/main so both the new
'Default to Heapdump Explorer' callout and the diff feature work
together.

Change-Id: I61f8e5e7f9988a89a7fd861b2e68ff9922568510

Author: zezeozue

Android.bp

@@ -808,7 +808,7 @@ cc_library_shared {
     ],
     shared_libs: [
         "android.hardware.atrace@1.0",
-        "android.hardware.health-V2-ndk",
+        "android.hardware.health-V5-ndk",
         "android.hardware.health@2.0",
         "android.hardware.power.stats-V1-cpp",
         "android.hardware.power.stats@1.0",
@@ -23159,8 +23159,8 @@ phony {
                 // TODO(primiano): uncomment after ag/38422283 lands.
                 // "system_tracing_protos_descriptor",
             ],
-        }
-    }
+        },
+    },
 }
 
 filegroup {

docs/heap_diff/README.md

@@ -0,0 +1,142 @@
+# Heap Dump Explorer — Diff feature
+
+End-to-end screenshots of every diff view in the Heap Dump Explorer.
+
+## Two diff modes
+
+The Heap Dump Explorer supports two diff workflows:
+
+1. **Same-trace diff** — two heap dumps in one trace. Activates the
+   *flamegraph diff* path with palette-modulated colouring (the
+   flamegraph is rendered with the standard per-name palette hues, but
+   each node is darkened / saturated for *grew*, lightened / desaturated
+   for *shrank*, kept neutral for *unchanged*, and pop-saturated for
+   *new*).
+
+2. **Cross-trace diff** — two separate traces (or hprofs) loaded as
+   primary + baseline. The Overview, Classes, Objects, Dominators,
+   Bitmaps, Strings and Arrays tabs show diff columns; the flamegraph
+   stays in single-engine mode because each trace has its own SQLite
+   engine.
+
+Status of each row is colour-coded: <span style="color:#c62828">**GREW
+/ NEW**</span> (red), <span style="color:#1565c0">**SHRANK / GONE**</span>
+(blue), gray for unchanged.
+
+## Same-trace fixture (synthetic, two snapshots in one pftrace)
+
+Built by `tools/heap_dump_diff_test_app/build_rich_fixture.py` →
+`test/data/heap_diff_multi.pftrace`. ~1400 objects across two
+Android-app-shaped snapshots: dump 1 has a busy UI (4 activities × 3
+fragments × …); dump 2 has a quieter UI but heavier background services
+and network connections. Some classes appear (`NewlyAddedClass`),
+disappear (`RemovedClass`), grow, shrink or stay flat.
+
+### Overview tab
+
+Reachable instances and bytes-retained-by-heap with Δ columns.
+
+![Overview](screenshots/01_overview_diff.png)
+
+### Flamegraph tab
+
+Same-trace flamegraph diff, palette colours preserved per class,
+saturation / lightness modulated by Δ direction. UI sub-tree (left:
+Application → Activity → Fragment → ViewHolder → TextView / ImageView →
+String / Bitmap) reads as vivid (grew). Service sub-tree (right:
+ServiceManager → BackgroundService → Worker → Task) reads as faded
+(shrank).
+
+![Flamegraph](screenshots/02_flamegraph_diff.png)
+
+### Classes tab
+
+Per-class diff breakdown. Status pills (GREW / SHRANK / NEW / GONE) and
+signed deltas next to baseline / current values.
+
+![Classes](screenshots/03_classes_diff.png)
+
+### Objects tab
+
+![Objects](screenshots/04_objects_diff.png)
+
+### Dominators tab
+
+Dominator-tree retained-size diff per root class (size, count, native
+size, retained obj count — all four columns are diffable).
+
+![Dominators](screenshots/05_dominators_diff.png)
+
+### Bitmaps tab
+
+![Bitmaps](screenshots/06_bitmaps_diff.png)
+
+### Strings tab
+
+![Strings](screenshots/07_strings_diff.png)
+
+### Arrays tab
+
+![Arrays](screenshots/08_arrays_diff.png)
+
+### Primary-dump popup
+
+The primary-dump selector showing the "Diff against this dump" section.
+Selecting another dump from the same trace activates the same-trace
+flamegraph diff.
+
+![Popup](screenshots/09_popup.png)
+
+## Cross-trace fixture (real JVM hprofs)
+
+Built by running the Java app at
+`tools/heap_dump_diff_test_app/HeapDumpDiffTest.java` against a 1-GB
+JVM. The app constructs an object graph with deep reference chains
+(Application → ActivityManager → … → byte[]), then calls
+`HotSpotDiagnosticMXBean.dumpHeap` twice with different scales between
+the two dumps. The resulting `current.hprof` (smaller, services-heavy)
+is opened as the primary trace and `baseline.hprof` (larger, UI-heavy)
+is loaded as the cross-trace baseline.
+
+### Overview (cross-trace)
+
+![Overview cross-trace](screenshots/cross_trace/01_overview_diff.png)
+
+### Classes (cross-trace)
+
+![Classes cross-trace](screenshots/cross_trace/03_classes_diff.png)
+
+### Dominators (cross-trace)
+
+![Dominators cross-trace](screenshots/cross_trace/05_dominators_diff.png)
+
+### Strings (cross-trace)
+
+![Strings cross-trace](screenshots/cross_trace/07_strings_diff.png)
+
+### Arrays (cross-trace)
+
+![Arrays cross-trace](screenshots/cross_trace/08_arrays_diff.png)
+
+## Reproducing locally
+
+```sh
+# Capture two real hprofs.
+cd tools/heap_dump_diff_test_app
+javac HeapDumpDiffTest.java
+java -Xmx1g HeapDumpDiffTest baseline.hprof current.hprof
+
+# Build the same-trace synthetic fixture.
+python3 build_rich_fixture.py
+out/ui/protoc --encode=perfetto.protos.Trace -I . protos/perfetto/trace/trace.proto \
+    < /tmp/hprof_test/multi_dump_rich.textproto \
+    > test/data/heap_diff_multi.pftrace
+
+# Serve the UI.
+cd ui && pnpm install && node build.js --serve --watch
+
+# In another shell, run the playwright e2e suites.
+cd ui && pnpm exec playwright test src/test/heap_dump_flamegraph_diff.test.ts
+cd ui && pnpm exec playwright test src/test/heap_dump_diff.test.ts
+cd ui && pnpm exec playwright test src/test/heap_dump_diff_hprof_primary.test.ts
+```