Canvas low latency: a few more cleanups

This CL has a few side cleanups to crrev.com/c/1321773, taken
out for clarity.
- Renames class
 CanvasResourceProviderRamGpuMemoryBuffer to
 CanvasResourceProviderBitmapGpuMemoryBuffer
- Moves calculation of |gl_format| to where it's used.

Bug: 902585
Change-Id: Ia0f0393425afd60ad98dbdd38f3ef5bc0d5e9e2f
Reviewed-on: https://chromium-review.googlesource.com/c/1321749
Commit-Queue: Miguel Casas <mcasas@chromium.org>
Reviewed-by: Fernando Serboncini <fserb@chromium.org>
Reviewed-by: Andres Calderon Jaramillo <andrescj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#606229}

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

@@ -97,17 +97,15 @@ bool CanvasResource::PrepareTransferableResource(
   DCHECK(IsValid());
 
   DCHECK(out_callback);
-  scoped_refptr<CanvasResource> this_ref(this);
   auto func = WTF::Bind(&ReleaseFrameResources, provider_,
-                        WTF::Passed(std::move(this_ref)));
+                        WTF::Passed(base::WrapRefCounted(this)));
   *out_callback = viz::SingleReleaseCallback::Create(std::move(func));
 
-  if (out_resource) {
-    if (SupportsAcceleratedCompositing())
-      return PrepareAcceleratedTransferableResource(out_resource, sync_mode);
-    return PrepareUnacceleratedTransferableResource(out_resource);
-  }
-  return true;
+  if (!out_resource)
+    return true;
+  if (SupportsAcceleratedCompositing())
+    return PrepareAcceleratedTransferableResource(out_resource, sync_mode);
+  return PrepareUnacceleratedTransferableResource(out_resource);
 }
 
 bool CanvasResource::PrepareAcceleratedTransferableResource(

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

@@ -28,16 +28,13 @@
 
 namespace blink {
 
-// CanvasResourceProviderTexture
-//==============================================================================
-//
-// * Renders to a texture managed by skia. Mailboxes are straight GL textures.
-// * Layers are not overlay candidates
-
 void CanvasResourceProvider::RecordTypeToUMA(ResourceProviderType type) {
   UMA_HISTOGRAM_ENUMERATION("Blink.Canvas.ResourceProviderType", type);
 }
 
+// * Renders to a texture managed by Skia. Mailboxes are backed by vanilla GL
+//   textures.
+// * Layers are not overlay candidates.
 class CanvasResourceProviderTexture : public CanvasResourceProvider {
  public:
   CanvasResourceProviderTexture(
@@ -142,13 +139,9 @@ class CanvasResourceProviderTexture : public CanvasResourceProvider {
   const bool is_origin_top_left_;
 };
 
-// CanvasResourceProviderTextureGpuMemoryBuffer
-//==============================================================================
-//
-// * Renders to a texture managed by skia. Mailboxes are
-//     gpu-accelerated platform native surfaces.
-// * Layers are overlay candidates
-
+// * Renders to a texture managed by Skia. Mailboxes are GPU-accelerated
+//   platform native surfaces.
+// * Layers are overlay candidates.
 class CanvasResourceProviderTextureGpuMemoryBuffer final
     : public CanvasResourceProviderTexture {
  public:
@@ -217,12 +210,8 @@ class CanvasResourceProviderTextureGpuMemoryBuffer final
   }
 };
 
-// CanvasResourceProviderBitmap
-//==============================================================================
-//
-// * Renders to a skia RAM-backed bitmap
-// * Mailboxing is not supported : cannot be directly composited
-
+// * Renders to a Skia RAM-backed bitmap.
+// * Mailboxing is not supported : cannot be directly composited.
 class CanvasResourceProviderBitmap : public CanvasResourceProvider {
  public:
   CanvasResourceProviderBitmap(
@@ -259,17 +248,13 @@ class CanvasResourceProviderBitmap : public CanvasResourceProvider {
   }
 };
 
-// CanvasResourceProviderRamGpuMemoryBuffer
-//==============================================================================
-//
-// * Renders to a ram memory buffer managed by skia
+// * Renders to a ram memory buffer managed by Skia
 // * Uses GpuMemoryBuffer to pass frames to the compositor
 // * Layers are overlay candidates
-
-class CanvasResourceProviderRamGpuMemoryBuffer final
+class CanvasResourceProviderBitmapGpuMemoryBuffer final
     : public CanvasResourceProviderBitmap {
  public:
-  CanvasResourceProviderRamGpuMemoryBuffer(
+  CanvasResourceProviderBitmapGpuMemoryBuffer(
       const IntSize& size,
       const CanvasColorParams color_params,
       base::WeakPtr<WebGraphicsContext3DProviderWrapper>
@@ -280,14 +265,14 @@ class CanvasResourceProviderRamGpuMemoryBuffer final
                                      std::move(context_provider_wrapper),
                                      std::move(resource_dispatcher)) {}
 
-  ~CanvasResourceProviderRamGpuMemoryBuffer() override = default;
+  ~CanvasResourceProviderBitmapGpuMemoryBuffer() override = default;
   bool SupportsDirectCompositing() const override { return true; }
   bool SupportsSingleBuffering() const override { return true; }
 
  private:
   scoped_refptr<CanvasResource> CreateResource() final {
     TRACE_EVENT0("blink",
-                 "CanvasResourceProviderRamGpuMemoryBuffer::CreateResource");
+                 "CanvasResourceProviderBitmapGpuMemoryBuffer::CreateResource");
 
     constexpr bool is_accelerated = false;
     return CanvasResourceGpuMemoryBuffer::Create(
@@ -297,7 +282,7 @@ class CanvasResourceProviderRamGpuMemoryBuffer final
 
   scoped_refptr<CanvasResource> ProduceFrame() final {
     TRACE_EVENT0("blink",
-                 "CanvasResourceProviderRamGpuMemoryBuffer::ProduceFrame");
+                 "CanvasResourceProviderBitmapGpuMemoryBuffer::ProduceFrame");
 
     DCHECK(GetSkSurface());
 
@@ -318,12 +303,8 @@ class CanvasResourceProviderRamGpuMemoryBuffer final
   }
 };
 
-// CanvasResourceProviderSharedBitmap
-//==============================================================================
-//
-// * Renders to a shared memory bitmap
-// * Uses SharedBitmaps to pass frames directly to the compositor
-
+// * Renders to a shared memory bitmap.
+// * Uses SharedBitmaps to pass frames directly to the compositor.
 class CanvasResourceProviderSharedBitmap : public CanvasResourceProviderBitmap {
  public:
   CanvasResourceProviderSharedBitmap(
@@ -371,9 +352,6 @@ class CanvasResourceProviderSharedBitmap : public CanvasResourceProviderBitmap {
   }
 };
 
-// CanvasResourceProvider base class implementation
-//==============================================================================
-
 enum CanvasResourceType {
   kTextureGpuMemoryBufferResourceType,
   kRamGpuMemoryBufferResourceType,
@@ -481,8 +459,10 @@ std::unique_ptr<CanvasResourceProvider> CanvasResourceProvider::Create(
                 gfx::Size(size), color_params.GetBufferFormat())) {
           continue;
         }
-        provider = std::make_unique<CanvasResourceProviderRamGpuMemoryBuffer>(
-            size, color_params, context_provider_wrapper, resource_dispatcher);
+        provider =
+            std::make_unique<CanvasResourceProviderBitmapGpuMemoryBuffer>(
+                size, color_params, context_provider_wrapper,
+                resource_dispatcher);
         break;
       case kSharedBitmapResourceType:
         if (!resource_dispatcher)

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

@@ -1421,25 +1421,25 @@ scoped_refptr<DrawingBuffer::ColorBuffer> DrawingBuffer::CreateColorBuffer(
       Platform::Current()->GetGpuMemoryBufferManager();
   if (ShouldUseChromiumImage()) {
     gfx::BufferFormat buffer_format;
-    GLenum gl_format = GL_NONE;
     if (allocate_alpha_channel_) {
       buffer_format = use_half_float_storage_ ? gfx::BufferFormat::RGBA_F16
                                               : gfx::BufferFormat::RGBA_8888;
-      gl_format = GL_RGBA;
     } else {
       DCHECK(!use_half_float_storage_);
       buffer_format = gfx::BufferFormat::RGBX_8888;
       if (gpu::IsImageFromGpuMemoryBufferFormatSupported(
               gfx::BufferFormat::BGRX_8888,
-              ContextProvider()->GetCapabilities()))
+              ContextProvider()->GetCapabilities())) {
         buffer_format = gfx::BufferFormat::BGRX_8888;
-      gl_format = GL_RGB;
+      }
     }
     gpu_memory_buffer = gpu_memory_buffer_manager->CreateGpuMemoryBuffer(
         gfx::Size(size), buffer_format, gfx::BufferUsage::SCANOUT,
         gpu::kNullSurfaceHandle);
     if (gpu_memory_buffer) {
       gpu_memory_buffer->SetColorSpace(storage_color_space_);
+      const GLenum gl_format = allocate_alpha_channel_ ? GL_RGBA : GL_RGB;
+
       image_id =
           gl_->CreateImageCHROMIUM(gpu_memory_buffer->AsClientBuffer(),
                                    size.Width(), size.Height(), gl_format);