Priyanka

This commit introduces significant **refactoring** and a **bug fix** to enhance **Winscope's compatibility with `google-protobuf`** and improve **Android trace parsing**. It updates numerous **Winscope protos** (e.g., `surfaceflinger_layers.proto`, `inputmethodeditor.proto`) by adding `jstype = JS_STRING` annotations to large integer fields, preventing precision loss when data is consumed by JavaScript. Additionally, enum definitions in protos like `activityinfo.proto` are reordered to ensure the first value is 0, aligning with `google-protobuf`'s default assumptions. Finally, a **bug fix** in the **trace processor's Winscope importer** for **SurfaceFlinger layers** corrects the handling of `layer_stack` in `ParseDisplay` and rectangle computations, leading to more accurate display data. This ensures **Winscope can correctly parse and display complex Android trace data**, particularly large numbers and SurfaceFlinger layer details.

This commit **enhances the `trace_processor`'s `AndroidInput` event parsing** by converting specific monotonic timestamp fields from `MotionEvent` and `KeyEvent` into `boottime`. It implements new logic within `src/trace_processor/importers/proto/winscope/android_input_event_parser.cc` to transform `down_time` and `kernel_time` values, subsequently adding these converted timestamps to the `args` table. This **feature enhancement** provides more consistent and correlatable timing information for Android input events, improving the accuracy of trace analysis within the **`winscope` module**. The change ensures that analysts can now query these critical input event timings using a unified `boottime` reference. Test outputs are updated to reflect the availability of these new `boottime` fields.

This commit **enhances the Winscope trace processor** by providing more detailed and accurate timestamp information for shell transitions, significantly improving the user experience. It introduces new `wm_abort_time_ns`, `merge_time_ns`, and `create_time_ns` fields to the **`WINDOW_MANAGER_SHELL_TRANSITIONS_TABLE` schema**, while also prioritizing send time over dispatch time for the primary transition timestamp. The **shell transition tracking logic** in `shell_transitions_tracker.cc` is **refactored** to centralize the calculation of transition statuses and durations, ensuring they are set consistently after all proto packets are processed. This **new capability** addresses a **bug** by offering clearer insights into the lifecycle of UI transitions within Winscope, particularly for pending and playing stages.

This commit introduces a **new capability** to report `SurfaceFlinger` layer border settings within the **Winscope rect table** in `trace_processor`. It modifies the `surfaceflinger_layers_rect_computation.cc` importer to extract `border_width` and `border_color` from `SurfaceFlinger` traces. These new fields are then added to the `WINSCOPE_TRACE_RECT_TABLE` definition and exposed via the `android_winscope_trace_rect` SQL view, allowing users to query and analyze layer border properties. This enhancement provides more detailed visual debugging information for **Android UI tracing** by making border configurations directly queryable.

This commit **fixes a bug** in the **Winscope trace processor** by ensuring that **SurfaceFlinger layer corner radii** are calculated correctly. The `GetCornerRadii` function in `src/trace_processor/importers/proto/winscope/surfaceflinger_layers_utils.h` is updated to properly incorporate **effective radii** into its calculation. This change significantly improves the **accuracy of Winscope's visualization** of rounded corners for SurfaceFlinger layers, which is crucial for debugging and understanding UI rendering. Supporting this fix, **new test utilities** were added for setting and serializing radii, alongside **comprehensive unit tests** to validate the corrected logic.

This commit introduces **support for WindowManager (WM) data** within the `proto-to-args-with-defaults` mechanism in Trace Processor. It involves **refactoring** the `WindowManagerParser` to prune child protos from `WindowManagerTraceEntry` before storage and parsing, and adding new cloning functions to specifically remove unnecessary fields. The `winscope_proto_to_args_with_defaults` intrinsic table function is enhanced to support conditional row skipping and dynamic field selection for WM tables, backed by new utility functions. This **new capability** optimizes the ingestion and querying of complex WindowManager trace data by reducing the amount of stored information and improving data relevance.

This commit introduces a **new capability** to the **Trace Processor** by adding a `has_invalid_elapsed_ts` boolean column to the **WindowManager** and **SurfaceFlinger layers** tables. This column is populated during proto import, specifically flagging entries where `elapsed_realtime_nanos` is zero, which is crucial for identifying invalid timestamps in converted legacy Winscope dumps. The change impacts the **Winscope data parsing** and **SQL querying** for Android UI performance traces, providing clearer insights into data validity. **Schema definitions** in `winscope_tables.py`, **proto parsers** (`surfaceflinger_layers_parser.cc`, `windowmanager_parser.cc`), and **SQL views** (`android_windowmanager.sql`) are updated to incorporate this new field. Comprehensive **diff tests** are also added and updated to validate the correct population and querying of the `has_invalid_elapsed_ts` column.

This commit introduces a **bug fix** to the **Trace Processor's Winscope importer**, specifically within the `WindowManager` hierarchy parsing logic. It modifies the `ParseTaskProto` function in `windowmanager_hierarchy_walker.cc` to implement a **fallback mechanism**: if a task fragment's window container is unavailable, the system will now attempt to use the task's own window container. This change ensures more robust and complete **Winscope trace data parsing** by preventing missing window container information for tasks, and also refines task name handling. New unit tests and sample proto data were added to validate this crucial fallback behavior, improving the reliability of **Winscope UI data representation**.

This commit **refactors** the **SurfaceFlinger layer extraction logic** within the `trace_processor`'s `winscope` importer. It introduces a **recursive solution** for traversing SurfaceFlinger layers, specifically implementing a **bottom-to-top extraction order** via `ExtractBottomToTop` and adjusting the sorting mechanism with `SortByZThenLayerId`. This **improves the accuracy and consistency** of how SurfaceFlinger layer data is processed, ensuring correct representation for analysis and visualization tools. The change addresses a bug related to layer traversal and is supported by updated unit tests in `surfaceflinger_layers_extractor_unittest.cc`.

This commit **extends the Perfetto Trace Processor's WinScope data model** by **introducing a `focused_display_id` column** to the **Android WindowManager tables**. This **new capability** involves updating the `WINDOW_MANAGER_TABLE` schema in `winscope_tables.py` and adding corresponding parsing logic in `windowmanager_parser.cc` to ingest this new data. The `android_windowmanager` SQL view is also updated in `windowmanager.sql` to expose this field, providing crucial data for **active display selection** and enhancing detailed analysis of display focus within WinScope.

This commit introduces a **new capability** to the **Trace Processor's Winscope WindowManager data processing**, enabling the extraction and storage of optional name overrides for window containers. The `WindowManagerHierarchyWalker` now parses and stores a `name_override` field for `Task` and `WindowState` containers, which is then persisted into the `android_windowmanager_windowcontainer` table. This **feature enhancement** is crucial for accurately representing and building the **WindowManager hierarchy**, providing more detailed and context-rich data for analysis within Winscope. The change extends the relevant SQL views and table definitions, and includes new unit tests to verify the correct handling of these overrides.

This commit **extends the Trace Processor's Winscope Window Manager (WM) tables** by introducing a new `container_type` column to the `WINDOW_MANAGER_WINDOW_CONTAINER_TABLE`. This **new capability** is crucial for accurately building and representing the hierarchy of window containers within Android traces. The change involves updating the `WindowManagerHierarchyWalker` to extract this type from proto data, modifying the internal data model and insertion logic, and exposing the new field through the `android_windowmanager_windowcontainer` SQL view. This enhancement provides more granular detail for **Winscope analysis**, enabling more sophisticated queries and visualizations of the Android UI stack.

This commit significantly **enhances the parsing of Winscope ViewCapture data** within the **trace processor**, introducing the capability to extract and compute **visibility and rectangle information** for views. The `ViewCaptureParser` and `ViewCaptureArgsParser` components were updated to process this new data, populating it directly into **new ViewCapture tables** and refactoring string de-interning for improved efficiency. This **new capability** provides richer UI performance analysis by making detailed view hierarchy and layout information queryable. Extensive test updates confirm the correct parsing and availability of this expanded dataset, ensuring robust data for Winscope analysis.

This commit introduces a **new capability** within the **Winscope trace processor** to **compute and store geometry for view capture rectangles**. It implements the `RectComputation` class, which calculates rectangle dimensions and inserts corresponding data into the `winscope` geometry tables. This enhancement is crucial for accurately representing and analyzing UI-related view capture traces, enabling better visualization and debugging within the Perfetto ecosystem.

This commit **introduces a new capability** to the **trace processor's Winscope importer** for computing the visibility of viewcapture views. It implements the `VisibilityComputation` class in `viewcapture_visibility_computation.cc` to accurately determine view visibility based on their properties and hierarchical relationships. This **new feature** significantly **enhances the analysis of UI state** within Winscope by providing precise visibility data for elements captured in view traces. The change includes necessary build system updates across Bazel, GN, and Android.bp, with correctness ensured by dedicated unit tests for the new computation logic.

This commit introduces a **new view capture extractor** within the `trace_processor/importers/proto/winscope` module, designed to process UI view hierarchy data. It implements functions like `ExtractViewsTopToBottom` to extract view capture nodes in **depth-first search (DFS) order**, which is crucial for accurate **visibility computation**. This **new capability** enhances the trace processor's ability to analyze UI view structures, supported by new unit tests and updated build configurations across Android, Bazel, and GN.

This commit introduces **new test utilities** for the **Trace Processor's `winscope` importer**, specifically designed to facilitate the creation of `ViewCapture` protocol buffers for testing. A new header, `src/trace_processor/importers/proto/winscope/viewcapture_test_utils.h`, provides helper classes with methods like `SetId`, `AddView`, and `Build` to programmatically construct complex `ViewCapture` test data. This **enhances the testing infrastructure** by simplifying the setup for unit tests that process `winscope` data, leading to more robust and reliable validation. The `BUILD.gn` file was updated to integrate these utilities into the `perfetto_unittests` build target.

This commit **enhances the Trace Processor's Winscope integration** by introducing several new eager property fields to the `android_viewcapture` and `android_viewcapture_view` SQL tables. This **feature addition** provides more detailed information for analyzing **Android ViewCapture traces**, making properties like `package_name`, `window_name`, `node_id`, `hashcode`, `is_visible`, `parent_id`, `view_id`, `class_name`, and `trace_rect_id` directly accessible. The changes involve updating the SQL view definitions in `src/trace_processor/perfetto_sql/stdlib/android/winscope/viewcapture.sql` and the underlying table schemas in `src/trace_processor/tables/winscope_tables.py`. This improves the depth of UI performance and state investigations by providing richer, readily available data.

This commit **fixes** a critical issue in **Winscope's trace analysis** by properly incorporating corner radii into geometric calculations, which previously led to incorrect occlusion and visibility determinations. It introduces a `CornerRadii` struct and integrates per-corner radius values into the `Rect` class within the `winscope_geometry` subsystem, updating `Rect::ContainsRect` for accurate containment checks. The **SurfaceFlinger layers visibility computation** is subsequently updated to leverage this enhanced geometry, ensuring precise `LayerContains` and `IsLayerVisible` results. This **improves the accuracy of Winscope's UI rendering analysis**, particularly for debugging issues like window manager flicker, and includes supporting refactoring and comprehensive unit tests.

This commit **fixes several issues** within the **Winscope trace processor importer's geometry calculations**, specifically correcting the `IsEmpty` logic and refining `ContainsRect` for robustness. It **refactors** geometry-related test utilities from `surfaceflinger_layers_test_utils.h` into a new dedicated header, `winscope_geometry_test_utils.h`, and **adds comprehensive unit tests** for the `Rect` class. These changes improve the accuracy and reliability of **Winscope's UI rendering** and data interpretation, especially for **SurfaceFlinger layer analysis**, by ensuring correct handling of rectangle properties and operations. The added tests provide better coverage and prevent future regressions in this critical component.