Remove gpu_compositing from ToClosestSkColorType

The are few callsites that can pass gpu_compositing = false, they are
renambed to ToClosestSkColorTypeDeprecated, so we can work on
eliminating them.

Hardcoding to N32 was needed only for SharedBitmaps.

Bug: 383575394
Change-Id: Idf22d09ece603b54ae2c8a485f21f1390267a354
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6089238
Reviewed-by: Colin Blundell <blundell@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Vasiliy Telezhnikov <vasilyt@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1405518}

cc/raster/raster_buffer_provider.cc

@@ -59,7 +59,8 @@ void RasterBufferProvider::PlaybackToMemory(
 
   DCHECK(IsSupportedPlaybackToMemoryFormat(format)) << format.ToString();
 
-  SkColorType color_type = ToClosestSkColorType(gpu_compositing, format);
+  SkColorType color_type =
+      ToClosestSkColorTypeDeprecated(gpu_compositing, format);
 
   // Uses kPremul_SkAlphaType since the result is not known to be opaque.
   SkImageInfo info = SkImageInfo::Make(size.width(), size.height(), color_type,
@@ -104,8 +105,8 @@ void RasterBufferProvider::PlaybackToMemory(
 
     TRACE_EVENT0("cc",
                  "RasterBufferProvider::PlaybackToMemory::ConvertRGBA4444");
-    SkImageInfo dst_info =
-        info.makeColorType(ToClosestSkColorType(gpu_compositing, format));
+    SkImageInfo dst_info = info.makeColorType(
+        ToClosestSkColorTypeDeprecated(gpu_compositing, format));
     auto dst_canvas =
         SkCanvas::MakeRasterDirect(dst_info, memory, stride, &surface_props);
     DCHECK(dst_canvas);

cc/tiles/tile_manager_unittest.cc

@@ -2159,7 +2159,7 @@ TEST_F(PixelInspectTileManagerTest, LowResHasNoImage) {
     EXPECT_TRUE(tile->draw_info().IsReadyToDraw());
 
     gfx::Size resource_size = tile->draw_info().resource_size();
-    SkColorType ct = ToClosestSkColorType(
+    SkColorType ct = ToClosestSkColorTypeDeprecated(
         TestSoftwareRasterBufferProvider::kIsGpuCompositing,
         TestSoftwareRasterBufferProvider::kSharedImageFormat);
     auto info = SkImageInfo::Make(resource_size.width(), resource_size.height(),

cc/trees/layer_tree_host_impl.cc

@@ -248,8 +248,7 @@ class LayerTreeHostImpl::ImageDecodeCacheHolder {
                          size_t decoded_image_working_set_budget_bytes,
                          RasterDarkModeFilter* dark_mode_filter) {
     if (raster_caps.use_gpu_rasterization) {
-      auto color_type = viz::ToClosestSkColorType(
-          /*gpu_compositing=*/true, raster_caps.tile_format);
+      auto color_type = viz::ToClosestSkColorType(raster_caps.tile_format);
       if (enable_shared_image_cache_for_gpu) {
         image_decode_cache_ptr_ =
             &worker_context_provider_wrapper->GetGpuImageDecodeCache(
@@ -263,7 +262,8 @@ class LayerTreeHostImpl::ImageDecodeCacheHolder {
       }
     } else {
       image_decode_cache_ = std::make_unique<SoftwareImageDecodeCache>(
-          viz::ToClosestSkColorType(gpu_compositing, raster_caps.tile_format),
+          viz::ToClosestSkColorTypeDeprecated(gpu_compositing,
+                                              raster_caps.tile_format),
           decoded_image_working_set_budget_bytes);
     }
 

components/viz/common/resources/shared_image_format_utils.cc

@@ -15,8 +15,8 @@
 
 namespace viz {
 
-SkColorType ToClosestSkColorType(bool gpu_compositing,
-                                 SharedImageFormat format) {
+SkColorType ToClosestSkColorTypeDeprecated(bool gpu_compositing,
+                                           SharedImageFormat format) {
   CHECK(format.is_single_plane());
 
   if (!gpu_compositing) {
@@ -28,6 +28,12 @@ SkColorType ToClosestSkColorType(bool gpu_compositing,
     return kN32_SkColorType;
   }
 
+  return ToClosestSkColorType(format);
+}
+
+SkColorType ToClosestSkColorType(SharedImageFormat format) {
+  CHECK(format.is_single_plane());
+
   if (format == SinglePlaneFormat::kRGBA_4444) {
     return kARGB_4444_SkColorType;
   } else if (format == SinglePlaneFormat::kRGBA_8888) {
@@ -72,7 +78,7 @@ SkColorType ToClosestSkColorType(bool gpu_compositing,
 SkColorType ToClosestSkColorType(SharedImageFormat format, int plane_index) {
   CHECK(format.IsValidPlaneIndex(plane_index));
   if (format.is_single_plane()) {
-    return ToClosestSkColorType(/*gpu_compositing=*/true, format);
+    return ToClosestSkColorType(format);
   }
 
   // No external sampling, format is per plane.

components/viz/common/resources/shared_image_format_utils.h

@@ -42,8 +42,14 @@ class TestInProcessContextProvider;
 // is always RGBA and there is no difference between RGBA/BGRA. Also, these
 // formats should not be used for software SkImages/SkSurfaces.
 COMPONENT_EXPORT(VIZ_SHARED_IMAGE_FORMAT)
-SkColorType ToClosestSkColorType(bool gpu_compositing,
-                                 SharedImageFormat format);
+SkColorType ToClosestSkColorType(SharedImageFormat format);
+
+// Legacy version of the above, allowing to set `gpu_compositing` to false,
+// which essentially hardcodes N32. This is due to how legacy SharedBitmap
+// worked.
+COMPONENT_EXPORT(VIZ_SHARED_IMAGE_FORMAT)
+SkColorType ToClosestSkColorTypeDeprecated(bool gpu_compositing,
+                                           SharedImageFormat format);
 
 // Returns the closest SkColorType for a given `format` that does not prefer
 // external sampler and `plane_index`. For single planar formats (eg. RGBA) the

components/viz/common/resources/shared_image_format_utils_unittest.cc

@@ -134,7 +134,7 @@ TEST_F(SharedImageFormatUtilsTest, ToClosestSkColorTypeSoftwareRGBX) {
   SharedImageFormat format = SinglePlaneFormat::kRGBX_8888;
   ASSERT_EQ(format.NumberOfPlanes(), 1);
   EXPECT_EQ(kN32_SkColorType,
-            ToClosestSkColorType(/*gpu_compositing=*/false, format));
+            ToClosestSkColorTypeDeprecated(/*gpu_compositing=*/false, format));
 }
 
 }  // namespace

components/viz/service/display/renderer_pixeltest.cc

@@ -4679,7 +4679,8 @@ TEST_P(RendererPixelTest, TileDrawQuadNearestNeighbor) {
   constexpr SharedImageFormat format = SinglePlaneFormat::kRGBA_8888;
   gfx::Rect viewport(this->device_viewport_size_);
 
-  SkColorType ct = ToClosestSkColorType(!is_software_renderer(), format);
+  SkColorType ct =
+      ToClosestSkColorTypeDeprecated(!is_software_renderer(), format);
   SkImageInfo info = SkImageInfo::Make(2, 2, ct, kPremul_SkAlphaType);
   SkBitmap bitmap;
   bitmap.allocPixels(info);

components/viz/service/display_embedder/skia_output_surface_impl.cc

@@ -630,7 +630,7 @@ void SkiaOutputSurfaceImpl::MakePromiseSkImageSinglePlane(
   SkColorType color_type =
       format.PrefersExternalSampler()
           ? gpu::ToClosestSkColorTypeExternalSampler(format)
-          : ToClosestSkColorType(/*gpu_compositing=*/true, format);
+          : ToClosestSkColorType(format);
 
   if (force_rgbx) {
     if (color_type == SkColorType::kBGRA_8888_SkColorType ||
@@ -848,8 +848,7 @@ SkCanvas* SkiaOutputSurfaceImpl::BeginPaintRenderPass(
   CHECK(!current_paint_);
   CHECK(resource_sync_tokens_.empty());
 
-  SkColorType color_type =
-      ToClosestSkColorType(/*gpu_compositing=*/true, format);
+  SkColorType color_type = ToClosestSkColorType(format);
   if (graphite_recorder_) {
     SkImageInfo image_info =
         SkImageInfo::Make(gfx::SizeToSkISize(surface_size), color_type,

components/viz/test/fake_skia_output_surface.cc

@@ -130,8 +130,7 @@ void FakeSkiaOutputSurface::MakePromiseSkImage(
     return;
   }
 
-  auto sk_color_type =
-      ToClosestSkColorType(true /* gpu_compositing */, image_context->format());
+  auto sk_color_type = ToClosestSkColorType(image_context->format());
   image_context->SetImage(
       SkImages::BorrowTextureFrom(gr_context(), backend_texture,
                                   kTopLeft_GrSurfaceOrigin, sk_color_type,
@@ -176,8 +175,7 @@ SkCanvas* FakeSkiaOutputSurface::BeginPaintRenderPass(
   auto& sk_surface = sk_surfaces_[id];
 
   if (!sk_surface) {
-    SkColorType color_type =
-        ToClosestSkColorType(true /* gpu_compositing */, format);
+    SkColorType color_type = ToClosestSkColorType(format);
     SkImageInfo image_info = SkImageInfo::Make(
         surface_size.width(), surface_size.height(), color_type,
         kPremul_SkAlphaType, std::move(color_space));

content/renderer/pepper/pepper_graphics_2d_host.cc

@@ -721,9 +721,9 @@ bool PepperGraphics2DHost::PrepareTransferableResource(
       src = swizzled.get();
     }
 
-    SkImageInfo src_info = SkImageInfo::Make(
-        size.width(), size.height(), viz::ToClosestSkColorType(true, format),
-        kUnknown_SkAlphaType);
+    SkImageInfo src_info = SkImageInfo::Make(size.width(), size.height(),
+                                             viz::ToClosestSkColorType(format),
+                                             kUnknown_SkAlphaType);
     ri->WaitSyncTokenCHROMIUM(in_sync_token.GetConstData());
 
     uint32_t texture_target = shared_image->GetTextureTarget();

gpu/command_buffer/service/raster_decoder.cc

@@ -1986,7 +1986,7 @@ void RasterDecoderImpl::DoWritePixelsINTERNAL(GLint x_offset,
   }
 
   viz::SharedImageFormat dest_format = dest_shared_image->format();
-  if (SkColorTypeBytesPerPixel(viz::ToClosestSkColorType(true, dest_format)) !=
+  if (SkColorTypeBytesPerPixel(viz::ToClosestSkColorType(dest_format)) !=
       SkColorTypeBytesPerPixel(static_cast<SkColorType>(src_sk_color_type))) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glWritePixels",
                        "Bytes per pixel for src SkColorType and dst "
@@ -2861,8 +2861,7 @@ void RasterDecoderImpl::DoBeginRasterCHROMIUM(GLfloat r,
   DCHECK(locked_handles_.empty());
   DCHECK(!raster_canvas_);
 
-  SkColorType sk_color_type = viz::ToClosestSkColorType(
-      /*gpu_compositing=*/true, shared_image->format());
+  SkColorType sk_color_type = viz::ToClosestSkColorType(shared_image->format());
 
   int final_msaa_count;
   uint32_t flags;

gpu/command_buffer/service/shared_image/ahardwarebuffer_image_backing_factory_unittest.cc

@@ -309,9 +309,8 @@ TEST_P(AHardwareBufferImageBackingFactoryTest, InitialData) {
   SkAlphaType alpha_type = kPremul_SkAlphaType;
   gpu::SharedImageUsageSet usage = SHARED_IMAGE_USAGE_DISPLAY_READ;
 
-  auto image_info =
-      SkImageInfo::Make(gfx::SizeToSkISize(size),
-                        viz::ToClosestSkColorType(true, format), alpha_type);
+  auto image_info = SkImageInfo::Make(
+      gfx::SizeToSkISize(size), viz::ToClosestSkColorType(format), alpha_type);
   SkBitmap expected_bitmap;
   expected_bitmap.allocPixels(image_info);
 

gpu/command_buffer/service/shared_image/dcomp_surface_image_backing.cc

@@ -385,8 +385,7 @@ sk_sp<SkSurface> DCompSurfaceImageBacking::BeginDrawGanesh(
   GrGLFramebufferInfo framebuffer_info = {0};
   DCHECK_EQ(gl_surface_->GetBackingFramebufferObject(), 0u);
 
-  SkColorType color_type = viz::ToClosestSkColorType(
-      /*gpu_compositing=*/true, format());
+  SkColorType color_type = viz::ToClosestSkColorType(format());
   switch (color_type) {
     case kRGBA_8888_SkColorType:
       framebuffer_info.fFormat = GL_RGBA8;

gpu/command_buffer/service/shared_image/raw_draw_image_backing.cc

@@ -190,8 +190,7 @@ bool RawDrawImageBacking::CreateBackendTextureAndFlushPaintOps(bool flush) {
   if (context_state_->context_lost())
     return false;
 
-  auto sk_color = viz::ToClosestSkColorType(
-      /*gpu_compositing=*/true, format());
+  auto sk_color = viz::ToClosestSkColorType(format());
   const std::string label =
       "RawDrawImageBacking" + CreateLabelForSharedImageUsage(usage());
   GrDirectContext* direct_context = context_state_->gr_context();

gpu/command_buffer/service/shared_image/shared_image_representation.cc

@@ -413,10 +413,9 @@ SkiaGaneshImageRepresentation::ScopedGaneshReadAccess::CreateSkImage(
   if (format.is_single_plane() || format.PrefersExternalSampler()) {
     DCHECK_EQ(static_cast<int>(promise_image_textures_.size()), 1);
     auto alpha_type = representation()->alpha_type();
-    auto color_type =
-        format.PrefersExternalSampler()
-            ? ToClosestSkColorTypeExternalSampler(format)
-            : viz::ToClosestSkColorType(/*gpu_compositing=*/true, format);
+    auto color_type = format.PrefersExternalSampler()
+                          ? ToClosestSkColorTypeExternalSampler(format)
+                          : viz::ToClosestSkColorType(format);
     return SkImages::BorrowTextureFrom(
         context_state->gr_context(), promise_image_texture()->backendTexture(),
         surface_origin, color_type, alpha_type, sk_color_space,
@@ -659,10 +658,9 @@ SkiaGraphiteImageRepresentation::ScopedGraphiteReadAccess::CreateSkImage(
   if (format.is_single_plane() || format.PrefersExternalSampler()) {
     CHECK_EQ(static_cast<int>(graphite_textures_.size()), 1);
     auto alpha_type = representation()->alpha_type();
-    auto color_type =
-        format.PrefersExternalSampler()
-            ? ToClosestSkColorTypeExternalSampler(format)
-            : viz::ToClosestSkColorType(/*gpu_compositing=*/true, format);
+    auto color_type = format.PrefersExternalSampler()
+                          ? ToClosestSkColorTypeExternalSampler(format)
+                          : viz::ToClosestSkColorType(format);
     auto origin = representation()->surface_origin() == kTopLeft_GrSurfaceOrigin
                       ? skgpu::Origin::kTopLeft
                       : skgpu::Origin::kBottomLeft;

gpu/command_buffer/service/shared_image/skia_vk_android_image_representation.cc

@@ -85,8 +85,7 @@ SkiaVkAndroidImageRepresentation::BeginWriteAccess(
 
   if (!surface_ || final_msaa_count != surface_msaa_count_ ||
       surface_props != surface_->props()) {
-    SkColorType sk_color_type = viz::ToClosestSkColorType(
-        /*gpu_compositing=*/true, format());
+    SkColorType sk_color_type = viz::ToClosestSkColorType(format());
     surface_ = SkSurfaces::WrapBackendTexture(
         gr_context, promise_texture_->backendTexture(), surface_origin(),
         final_msaa_count, sk_color_type, color_space().ToSkColorSpace(),

third_party/blink/renderer/modules/canvas/canvas2d/base_rendering_context_2d.cc

@@ -4001,7 +4001,7 @@ GPUTexture* BaseRenderingContext2D::transferToGPUTexture(
   }
 
   wgpu::TextureFormat dawn_format =
-      AsDawnType(viz::ToClosestSkColorType(true, client_si->format()));
+      AsDawnType(viz::ToClosestSkColorType(client_si->format()));
   wgpu::TextureDescriptor desc = {
       .usage = tex_usage,
       .size = {base::checked_cast<uint32_t>(client_si->size().width()),

third_party/blink/renderer/modules/webgpu/gpu_canvas_context.cc

@@ -115,8 +115,7 @@ SkColorType GPUCanvasContext::GetSkColorType() const {
   if (!swap_buffers_) {
     return kN32_SkColorType;
   }
-  return viz::ToClosestSkColorType(
-      /*gpu_compositing=*/true, swap_buffers_->Format());
+  return viz::ToClosestSkColorType(swap_buffers_->Format());
 }
 
 sk_sp<SkColorSpace> GPUCanvasContext::GetSkColorSpace() const {
@@ -311,8 +310,7 @@ ImageBitmap* GPUCanvasContext::TransferToImageBitmap(
   }
   DCHECK(release_callback);
 
-  auto sk_color_type = viz::ToClosestSkColorType(
-      /*gpu_compositing=*/true, client_si->format());
+  auto sk_color_type = viz::ToClosestSkColorType(client_si->format());
 
   const SkImageInfo sk_image_info = SkImageInfo::Make(
       texture_descriptor_.size.width, texture_descriptor_.size.height,

third_party/blink/renderer/platform/graphics/canvas_resource.cc

@@ -236,10 +236,9 @@ bool CanvasResource::PrepareTransferableResource(
 }
 
 SkImageInfo CanvasResource::CreateSkImageInfo() const {
-  return SkImageInfo::Make(
-      SkISize::Make(size_.width(), size_.height()),
-      viz::ToClosestSkColorType(/*gpu_compositing=*/true, format_), alpha_type_,
-      color_space_.ToSkColorSpace());
+  return SkImageInfo::Make(SkISize::Make(size_.width(), size_.height()),
+                           viz::ToClosestSkColorType(format_), alpha_type_,
+                           color_space_.ToSkColorSpace());
 }
 
 // CanvasResourceSharedBitmap

third_party/blink/renderer/platform/graphics/gpu/drawing_buffer.cc

@@ -748,8 +748,7 @@ scoped_refptr<StaticBitmapImage> DrawingBuffer::TransferToStaticBitmapImage() {
   DCHECK_EQ(size_.width(), shared_image->size().width());
   DCHECK_EQ(size_.height(), shared_image->size().height());
 
-  auto sk_color_type = viz::ToClosestSkColorType(
-      /*gpu_compositing=*/true, shared_image->format());
+  auto sk_color_type = viz::ToClosestSkColorType(shared_image->format());
 
   const SkImageInfo sk_image_info = SkImageInfo::Make(
       size_.width(), size_.height(), sk_color_type, kPremul_SkAlphaType);