0

[//cc] Fold BitmapRasterBufferProvider into ZeroCopyRasterBufferProvider

Makes the minimal adjustments to the latter necessary to have it behave
exactly as the former when used with software compositing.

Bug: 403372453
Change-Id: Ida8e3ed630a30ae8300a708de94e55324e8c407d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6401014
Commit-Queue: Colin Blundell <blundell@chromium.org>
Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1439280}
This commit is contained in:
Colin Blundell
2025-03-28 02:19:49 -07:00
committed by Chromium LUCI CQ
parent fec5b6a205
commit 7df30f3236
10 changed files with 51 additions and 172 deletions

@ -229,8 +229,6 @@ cc_component("cc") {
"metrics/ukm_smoothness_data.h",
"metrics/video_playback_roughness_reporter.cc",
"metrics/video_playback_roughness_reporter.h",
"raster/bitmap_raster_buffer_provider.cc",
"raster/bitmap_raster_buffer_provider.h",
"raster/categorized_worker_pool.cc",
"raster/categorized_worker_pool.h",
"raster/gpu_raster_buffer_provider.cc",

@ -1,83 +0,0 @@
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cc/raster/bitmap_raster_buffer_provider.h"
#include <stddef.h>
#include <stdint.h>
#include <utility>
#include "base/memory/raw_ptr.h"
#include "base/trace_event/process_memory_dump.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/traced_value.h"
#include "cc/raster/raster_buffer.h"
#include "cc/raster/zero_copy_raster_buffer_provider.h"
#include "cc/trees/layer_tree_frame_sink.h"
#include "components/viz/client/client_resource_provider.h"
#include "components/viz/common/resources/shared_image_format.h"
#include "gpu/command_buffer/client/client_shared_image.h"
#include "gpu/command_buffer/common/shared_image_usage.h"
#include "gpu/ipc/client/client_shared_image_interface.h"
#include "ui/gfx/color_space.h"
#include "url/gurl.h"
namespace cc {
BitmapRasterBufferProvider::BitmapRasterBufferProvider(
LayerTreeFrameSink* frame_sink)
: shared_image_interface_(frame_sink->shared_image_interface()) {
CHECK(shared_image_interface_)
<< "SharedImageInterface is null in BitmapRasterBufferProvider ctor!";
}
BitmapRasterBufferProvider::~BitmapRasterBufferProvider() = default;
std::unique_ptr<RasterBuffer>
BitmapRasterBufferProvider::AcquireBufferForRaster(
const ResourcePool::InUsePoolResource& resource,
uint64_t resource_content_id,
uint64_t previous_content_id,
bool depends_on_at_raster_decodes,
bool depends_on_hardware_accelerated_jpeg_candidates,
bool depends_on_hardware_accelerated_webp_candidates) {
bool resource_has_previous_content =
resource_content_id && resource_content_id == previous_content_id;
return std::make_unique<ZeroCopyRasterBufferImpl>(
resource, shared_image_interface_, resource_has_previous_content,
/*is_software=*/true);
}
void BitmapRasterBufferProvider::Flush() {}
viz::SharedImageFormat BitmapRasterBufferProvider::GetFormat() const {
return viz::SinglePlaneFormat::kBGRA_8888;
}
bool BitmapRasterBufferProvider::IsResourcePremultiplied() const {
return true;
}
bool BitmapRasterBufferProvider::CanPartialRasterIntoProvidedResource() const {
return true;
}
bool BitmapRasterBufferProvider::IsResourceReadyToDraw(
const ResourcePool::InUsePoolResource& resource) {
// Bitmap resources are immediately ready to draw.
return true;
}
uint64_t BitmapRasterBufferProvider::SetReadyToDrawCallback(
const std::vector<const ResourcePool::InUsePoolResource*>& resources,
base::OnceClosure callback,
uint64_t pending_callback_id) {
// Bitmap resources are immediately ready to draw.
return 0;
}
void BitmapRasterBufferProvider::Shutdown() {}
} // namespace cc

@ -1,70 +0,0 @@
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_RASTER_BITMAP_RASTER_BUFFER_PROVIDER_H_
#define CC_RASTER_BITMAP_RASTER_BUFFER_PROVIDER_H_
#include <stdint.h>
#include <memory>
#include <vector>
#include "base/memory/raw_ptr.h"
#include "cc/raster/raster_buffer_provider.h"
namespace base {
namespace trace_event {
class ConvertableToTraceFormat;
}
}
namespace gpu {
class SharedImageInterface;
}
namespace cc {
class LayerTreeFrameSink;
class CC_EXPORT BitmapRasterBufferProvider : public RasterBufferProvider {
public:
BitmapRasterBufferProvider(const BitmapRasterBufferProvider&) = delete;
~BitmapRasterBufferProvider() override;
BitmapRasterBufferProvider& operator=(const BitmapRasterBufferProvider&) =
delete;
explicit BitmapRasterBufferProvider(LayerTreeFrameSink* frame_sink);
// Overridden from RasterBufferProvider:
std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
const ResourcePool::InUsePoolResource& resource,
uint64_t resource_content_id,
uint64_t previous_content_id,
bool depends_on_at_raster_decodes,
bool depends_on_hardware_accelerated_jpeg_candidates,
bool depends_on_hardware_accelerated_webp_candidates) override;
viz::SharedImageFormat GetFormat() const override;
bool IsResourcePremultiplied() const override;
bool CanPartialRasterIntoProvidedResource() const override;
bool IsResourceReadyToDraw(
const ResourcePool::InUsePoolResource& resource) override;
uint64_t SetReadyToDrawCallback(
const std::vector<const ResourcePool::InUsePoolResource*>& resources,
base::OnceClosure callback,
uint64_t pending_callback_id) override;
void Shutdown() override;
protected:
void Flush() override;
private:
std::unique_ptr<base::trace_event::ConvertableToTraceFormat> StateAsValue()
const;
scoped_refptr<gpu::SharedImageInterface> shared_image_interface_;
};
} // namespace cc
#endif // CC_RASTER_BITMAP_RASTER_BUFFER_PROVIDER_H_

@ -20,7 +20,6 @@
#include "base/time/time.h"
#include "base/timer/lap_timer.h"
#include "build/build_config.h"
#include "cc/raster/bitmap_raster_buffer_provider.h"
#include "cc/raster/gpu_raster_buffer_provider.h"
#include "cc/raster/one_copy_raster_buffer_provider.h"
#include "cc/raster/raster_query_queue.h"
@ -394,8 +393,9 @@ class RasterBufferProviderPerfTest
break;
case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
CreateSoftwareResourceProvider();
raster_buffer_provider_ = std::make_unique<BitmapRasterBufferProvider>(
layer_tree_frame_sink_.get());
raster_buffer_provider_ =
std::make_unique<ZeroCopyRasterBufferProvider>(
layer_tree_frame_sink_.get());
break;
}
DCHECK(raster_buffer_provider_);
@ -561,7 +561,7 @@ class RasterBufferProviderPerfTest
case RASTER_BUFFER_PROVIDER_TYPE_GPU:
return std::string("_gpu_raster_buffer_provider");
case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
return std::string("_bitmap_raster_buffer_provider");
return std::string("_sw_compositing_zero_copy_raster_buffer_provider");
}
NOTREACHED();
}

@ -31,7 +31,6 @@
#include "build/build_config.h"
#include "cc/base/unique_notifier.h"
#include "cc/paint/draw_image.h"
#include "cc/raster/bitmap_raster_buffer_provider.h"
#include "cc/raster/gpu_raster_buffer_provider.h"
#include "cc/raster/one_copy_raster_buffer_provider.h"
#include "cc/raster/raster_query_queue.h"
@ -200,8 +199,9 @@ class RasterBufferProviderTest
break;
case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
CreateSoftwareResourceProvider();
raster_buffer_provider_ = std::make_unique<BitmapRasterBufferProvider>(
layer_tree_frame_sink_.get());
raster_buffer_provider_ =
std::make_unique<ZeroCopyRasterBufferProvider>(
layer_tree_frame_sink_.get());
break;
}

@ -14,6 +14,7 @@
#include "base/trace_event/trace_event.h"
#include "base/trace_event/traced_value.h"
#include "cc/resources/resource_pool.h"
#include "cc/trees/layer_tree_frame_sink.h"
#include "components/viz/client/client_resource_provider.h"
#include "components/viz/common/gpu/raster_context_provider.h"
#include "components/viz/common/resources/platform_color.h"
@ -22,6 +23,7 @@
#include "gpu/command_buffer/client/shared_image_interface.h"
#include "gpu/command_buffer/common/shared_image_trace_utils.h"
#include "gpu/command_buffer/common/shared_image_usage.h"
#include "gpu/ipc/client/client_shared_image_interface.h"
#include "ui/gfx/buffer_format_util.h"
#include "url/gurl.h"
@ -42,7 +44,8 @@ ZeroCopyRasterBufferImpl::ZeroCopyRasterBufferImpl(
is_software_(is_software) {
if (!in_use_resource.backing()) {
if (is_software) {
in_use_resource.InstallSoftwareBacking(sii, "BitmapRasterBufferProvider");
in_use_resource.InstallSoftwareBacking(
sii, "ZeroCopyRasterBufferProviderSoftware");
in_use_resource.backing()->mailbox_sync_token =
sii->GenVerifiedSyncToken();
} else {
@ -168,6 +171,14 @@ ZeroCopyRasterBufferProvider::ZeroCopyRasterBufferProvider(
: compositor_context_provider_(compositor_context_provider),
tile_format_(raster_caps.tile_format) {}
ZeroCopyRasterBufferProvider::ZeroCopyRasterBufferProvider(
LayerTreeFrameSink* frame_sink)
: is_software_(true),
shared_image_interface_(frame_sink->shared_image_interface()) {
CHECK(shared_image_interface_)
<< "SharedImageInterface is null in ZeroCopyRasterBufferProvider ctor!";
}
ZeroCopyRasterBufferProvider::~ZeroCopyRasterBufferProvider() = default;
std::unique_ptr<RasterBuffer>
@ -178,6 +189,14 @@ ZeroCopyRasterBufferProvider::AcquireBufferForRaster(
bool depends_on_at_raster_decodes,
bool depends_on_hardware_accelerated_jpeg_candidates,
bool depends_on_hardware_accelerated_webp_candidates) {
if (is_software_) {
bool resource_has_previous_content =
resource_content_id && resource_content_id == previous_content_id;
return std::make_unique<ZeroCopyRasterBufferImpl>(
resource, shared_image_interface_, resource_has_previous_content,
/*is_software=*/true);
}
return std::make_unique<ZeroCopyRasterBufferImpl>(
resource,
base::WrapRefCounted(
@ -188,7 +207,7 @@ ZeroCopyRasterBufferProvider::AcquireBufferForRaster(
void ZeroCopyRasterBufferProvider::Flush() {}
viz::SharedImageFormat ZeroCopyRasterBufferProvider::GetFormat() const {
return tile_format_;
return (is_software_) ? viz::SinglePlaneFormat::kBGRA_8888 : tile_format_;
}
bool ZeroCopyRasterBufferProvider::IsResourcePremultiplied() const {
@ -197,7 +216,7 @@ bool ZeroCopyRasterBufferProvider::IsResourcePremultiplied() const {
bool ZeroCopyRasterBufferProvider::CanPartialRasterIntoProvidedResource()
const {
return false;
return is_software_;
}
bool ZeroCopyRasterBufferProvider::IsResourceReadyToDraw(

@ -22,7 +22,12 @@ class ConvertableToTraceFormat;
}
}
namespace gpu {
class SharedImageInterface;
}
namespace cc {
class LayerTreeFrameSink;
// RasterBuffer for the zero copy upload, which is given to the raster worker
// threads for raster/upload.
@ -65,6 +70,10 @@ class CC_EXPORT ZeroCopyRasterBufferProvider : public RasterBufferProvider {
ZeroCopyRasterBufferProvider(
viz::RasterContextProvider* compositor_context_provider,
const RasterCapabilities& raster_caps);
// Constructor used with software compositing.
explicit ZeroCopyRasterBufferProvider(LayerTreeFrameSink* frame_sink);
ZeroCopyRasterBufferProvider(const ZeroCopyRasterBufferProvider&) = delete;
~ZeroCopyRasterBufferProvider() override;
@ -97,8 +106,14 @@ class CC_EXPORT ZeroCopyRasterBufferProvider : public RasterBufferProvider {
std::unique_ptr<base::trace_event::ConvertableToTraceFormat> StateAsValue()
const;
bool is_software_ = false;
// Used with the GPU compositor.
raw_ptr<viz::RasterContextProvider> compositor_context_provider_;
const viz::SharedImageFormat tile_format_;
// Used with the software compositor.
scoped_refptr<gpu::SharedImageInterface> shared_image_interface_;
};
} // namespace cc

@ -6,7 +6,6 @@
#include "base/task/single_thread_task_runner.h"
#include "cc/layers/layer.h"
#include "cc/raster/bitmap_raster_buffer_provider.h"
#include "cc/raster/gpu_raster_buffer_provider.h"
#include "cc/raster/one_copy_raster_buffer_provider.h"
#include "cc/raster/raster_buffer_provider.h"
@ -77,7 +76,7 @@ LayerTreeHostPixelResourceTest::CreateRasterBufferProvider(
EXPECT_FALSE(compositor_context_provider);
EXPECT_TRUE(use_software_renderer());
return std::make_unique<BitmapRasterBufferProvider>(
return std::make_unique<ZeroCopyRasterBufferProvider>(
host_impl->layer_tree_frame_sink());
case TestRasterType::kGpu:
EXPECT_TRUE(compositor_context_provider);

@ -81,7 +81,6 @@
#include "cc/paint/display_item_list.h"
#include "cc/paint/paint_worklet_job.h"
#include "cc/paint/paint_worklet_layer_painter.h"
#include "cc/raster/bitmap_raster_buffer_provider.h"
#include "cc/raster/gpu_raster_buffer_provider.h"
#include "cc/raster/one_copy_raster_buffer_provider.h"
#include "cc/raster/raster_buffer_provider.h"
@ -4191,7 +4190,8 @@ LayerTreeHostImpl::CreateRasterBufferProvider() {
layer_tree_frame_sink_->context_provider();
if (!compositor_context_provider) {
return std::make_unique<BitmapRasterBufferProvider>(layer_tree_frame_sink_);
return std::make_unique<ZeroCopyRasterBufferProvider>(
layer_tree_frame_sink_);
}
const gpu::Capabilities& caps =

@ -269,12 +269,13 @@ Chrome never mixes software compositing with hardware raster, but the other thre
The compositing mode affects the choice of RasterBufferProvider that cc provides, which manages the raster process and resource management on the raster worker threads:
* BitmapRasterBufferProvider: rasters software bitmaps for software compositing
* ZeroCopyRasterBufferProvider: rasters software bitmaps (a) for software
compositing into shared memory that is read directly by the software compositor
and (b) for gpu compositing directly into a GpuMemoryBuffer (e.g. IOSurface),
which is memory that can be mapped by CPU and used by the GPU
* OneCopyRasterBufferProvider: rasters software bitmaps for gpu compositing into shared memory, which are then uploaded to gpu memory in the gpu process
* ZeroCopyRasterBufferProvider: rasters software bitmaps for gpu compositing directly into a GpuMemoryBuffer (e.g. IOSurface), which is memory that can be mapped by CPU and used by the GPU
* GpuRasterBufferProvider: rasters gpu textures for gpu compositing over a command buffer via paint commands (for gpu raster)
Note, due to locks on the context, gpu raster is limited to one worker thread at a time, although image decoding can proceed in parallel on other threads.