Jorge Betancourt

This commit introduces `SkPixelStorage`, a **new abstract base class** designed to unify the identification of objects that hold pixel data within Skia. This **refactoring** provides a common interface for retrieving a unique ID and type, which is crucial for **logging and debugging** purposes. Both `SkPixelRef` (core Skia) and `TextureProxy` (Graphite GPU backend) are updated to inherit from `SkPixelStorage`, implementing their respective `type()` methods. This **enhances observability** by allowing consistent tracking of pixel blocks across different subsystems, improving the ability to diagnose issues related to pixel manipulation.

This commit **relands** the **deletion of staging functions** used for **serialization and deserialization**, effectively removing temporary or deprecated code from the codebase. This **maintenance** task was previously reverted due to breaking the Android build, but a **missed callsite** that depended on these functions has now been corrected. The successful re-application of this change ensures proper code cleanup and improves the overall code hygiene by removing unused components.

This commit **reverts** a previous change, thereby **restoring** the `serializeImage` and `deserializeImage` staging functions within the **Skia sharing process tools**. Specifically, it re-adds these methods to `SkSharingSerialContext` and `SkSharingDeserialContext` in `tools/SkSharingProc.h` and `tools/SkSharingProc.cpp`. This **critical revert** is a **regression fix** necessitated by the original deletion **breaking the Android roller**. By restoring these image serialization and deserialization capabilities, the commit ensures the stability and continued functionality of the Android build system and other downstream consumers.

This commit performs a **code cleanup** by **deleting staging functions** previously used for **serialization and deserialization** operations. These temporary functions are no longer required, indicating either their functionality has been integrated into stable APIs or the experimental feature they supported has been removed. The change primarily affects the **data handling infrastructure**, streamlining the codebase and **reducing technical debt** by removing obsolete code paths. This is a **maintenance** task that improves the overall clarity and maintainability of the project.

This commit performs a significant **refactoring** of **image serialization and deserialization** within Skia's picture sharing mechanisms, specifically by adopting a modern `imageDataProc` and a new `SkSharingContext` API. It updates image deserialization procedures in **MSKPPlayer**, **skpbench**, and `CanvasKit`'s `debugger_bindings.cpp` to use these new methods. The core logic is centralized in `tools/SkSharingProc.cpp` and `tools/SkSharingProc.h`, and relevant tests are updated. Crucially, this re-land includes staging functions to ensure **Android compatibility** by temporarily retaining the old serialization implementation.

This commit **enhances the Skia logging system** by introducing a new `kInfo` logging priority and a corresponding `SKIA_LOG_I` macro for informational messages. It also **adjusts the default log level for debug builds to `Debug`**, providing more verbose output during development. The change impacts the core **logging infrastructure** defined in `SkLog.h` and `SkLogPriority.h`, and ensures proper mapping for the **Android platform** within `SkLog_android.cpp`. This **new capability** improves the **diagnosability** of Skia applications by offering finer-grained control over log output and making debug builds more informative by default.

This commit **finalizes the migration** of logging priority management, **deleting the legacy Graphite-based system** and fully integrating it into **core Skia**. This **maintenance** and **cleanup** effort ensures that all logging priority decisions are now handled centrally within Skia's **logging subsystem**. Moving forward, developers should exclusively use the macros defined in `SkLog.h` for all debugging statements, warnings, and failure messages. A corresponding entry in `relnotes/logging.md` documents this significant shift in logging practices.

This commit performs a **logging refactoring** within the **Skia Ganesh GPU backend** for **Android hardware buffer integration**. It replaces direct `SkDebugf` calls with the more specific `SKIA_LOG_E` macro for error reporting in `AHardwareBufferGL.cpp` and `AHardwareBufferVk.cpp`. This **maintenance** change primarily affects the `rebind`, `make_gl_backend_texture`, and `make_vk_backend_texture` functions, ensuring **consistent and structured error logging** when handling Android hardware buffers with both OpenGL and Vulkan backends. The update improves internal diagnostics for issues related to hardware buffer creation and rebinding without altering external behavior or API.

This commit **relands** a previous change to **redirect GPU logging macros** from `SKGPU_LOG` to the **core Skia logging system** `SKIA_LOG`. It **fixes a bug** related to incorrect priority mapping by introducing a `MapGraphitePriority` function in `include/private/base/SkLog.h` to correctly translate `skgpu::graphite::LogPriority` to `SkLogPriority`. This **refactoring** unifies the logging infrastructure for the **Graphite GPU backend**, ensuring that all GPU-related logs are processed consistently through the central Skia logging mechanism. The change improves the accuracy of log priority handling and streamlines logging practices across the project.

This commit **refactors** the **GPU Graphite logging system** by redirecting all `SKGPU_LOG` macros to utilize the more general `SKIA_LOG` infrastructure. It removes custom logging priority definitions from `src/gpu/graphite/Log.h`, streamlining the logging mechanism within the module. This **refactoring** ensures consistency in logging practices across Skia and affects how log messages are generated within the Graphite module. Specifically, functions like `log_map_error` in `src/gpu/graphite/dawn/DawnBuffer.cpp` are updated to conform to the new `SKIA_LOG` system.

This commit performs **maintenance cleanup** by removing **legacy debug files** from the repository. These files were likely generated during past development or testing cycles and are no longer necessary, contributing to repository clutter. The change primarily affects the **development environment** and **repository hygiene**, reducing overall repository size and improving clarity for contributors.

This commit **reverts** a previous refactoring that aimed to clean up **Ganesh's Direct3D backend** by converting helper types to use smart pointers. Specifically, it undoes the change to `GrD3DBackendSurfaceInfo`, restoring its original design with raw pointers and manual resource management, and re-introduces the `GrD3DTextureResourceSpecHolder` struct. This **bug fix** addresses a critical regression where the smart pointer refactoring was **breaking D3D functionality**. The revert ensures the **stability and correctness of the Direct3D GPU backend** by restoring the proven resource handling logic across `GrD3DTypesMinimal.h`, `GrBackendSurface.cpp`, and `GrD3DTypesMinimal.cpp`.

This commit introduces **temporary placeholder files** (`SkDebug_android.cpp`, `SkDebug_stdio.cpp`, `SkDebug_win.cpp`) into the **Skia porting layer** (`src/ports`). This **maintenance chore** is a **workaround** specifically designed to **resolve build errors** within the **Flutter roller**, which was failing due to missing files during a renaming effort. The new files simply include their respective `SkLog_*.cpp` counterparts, ensuring that Flutter's build process can proceed without disruption. These placeholders are not integrated into Skia's own build system and will be removed once the underlying file renaming is complete, serving only to **unblock downstream Flutter builds**.

This commit **introduces a new, prioritized logging system** to Skia by adding `SkLog` and `SkLogVAList` functions that accept an `SkLogPriority`. It **refactors the entire logging infrastructure**, replacing the older `SkDebugf` with the new API and migrating platform-specific implementations for **Android**, **Windows**, and **standard I/O** to use the new `SkLogVAList` with appropriate priority mapping. This **major refactoring** provides a **unified and more granular control** over log messages, significantly **enhancing Skia's logging capabilities** and improving debuggability across various platforms.

This commit **introduces a new logging system** to Skia, defining the `SkLogPriority` enum for message severity and new logging macros such as `SKIA_LOG` and `SKIA_LOG_E`. This **new capability** significantly enhances **Skia's core logging infrastructure**, allowing for more structured categorization and control over log output. The work is a **reland** that specifically resolves a critical circular dependency issue in the build system, which previously caused G3 roller failures. It affects **private base headers** (`include/private/base/SkLog.h`, `SkLogPriority.h`) and build configurations (`gn/core.gni`, `include/private/base/BUILD.bazel`), providing a more robust and maintainable logging solution for the project.

This commit **introduces a new logging system** to the **Skia core library**, defining an `SkLogPriority` enum to categorize log messages by severity and providing `SKIA_LOG` macros for structured logging. This **new capability** allows developers to control log verbosity based on build configurations, enhancing debugging and diagnostic capabilities. The work involves **refactoring** `SkLoadUserConfig.h` to integrate the new priority system and includes **maintenance** updates to the **build systems** (GN and Bazel) to incorporate the new `SkLog.h` and `SkLogPriority.h` headers. This change provides a standardized and configurable approach to logging within Skia.

This commit **reverts** a previous change that introduced a new **Skia logging system**, including `SkLogPriority` and associated logging macros. This **maintenance** action was necessary because the original change was **blocking the g3 roller**, indicating a critical integration issue. Consequently, the **Skia codebase** will continue to use its existing logging mechanisms, preventing the adoption of the proposed new logging infrastructure and ensuring build stability.

This commit **introduces a new, standardized logging system** to Skia, establishing foundational components for improved debugging and observability. It adds `include/core/SkLogPriority.h` to define an enum class for various logging levels and `include/private/base/SkLog.h` which provides new logging macros such as `SKIA_LOG` and `SKIA_LOG_F`, along with logic for determining the lowest active log priority. This **new capability** significantly enhances Skia's **core logging infrastructure**, offering a unified and controlled way to emit log messages across the codebase. Build configurations for both GN and Bazel are updated to properly include these new header files.

This commit **reverts** a previous change that relocated `PaintParamsTestUtils.cpp` within the **Graphite testing infrastructure**. It **restores** the `PaintParamsTestUtils.cpp` file to its original `precompile` directory and reverts the corresponding updates in `gn/tests.gni` and other test files like `PaintParamsKeyTest.cpp`. This **maintenance revert** addresses a build issue on Android, ensuring the **Graphite test suite** compiles correctly by restoring the expected file paths and build configurations.

This commit is a **maintenance revert** that **restores the previous state** of the **Graphite testing framework**. It re-integrates a large set of utility functions and helper enums for generating random paint parameters and effects directly back into `tests/graphite/precompile/PaintParamsKeyTest.cpp`. This action **undoes a refactoring** that separated these input generation utilities, specifically to **unblock the Android roller** which was impacted by the original change. The revert ensures the stability and functionality of the `PaintParamsKeyTest` by rolling back the problematic separation.