Implement WebGL's commit with software compositing

third_party/WebKit/Source/platform/graphics/OffscreenCanvasFrameDispatcherImpl.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/OffscreenCanvasFrameDispatcherImpl.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
@@ skipping 34 matching lines @@
       m_binding(this) {
   DCHECK(!m_sink.is_bound());
   mojom::blink::OffscreenCanvasCompositorFrameSinkProviderPtr provider;
   Platform::current()->interfaceProvider()->getInterface(
       mojo::GetProxy(&provider));
   provider->CreateCompositorFrameSink(m_surfaceId,
                                       m_binding.CreateInterfacePtrAndBind(),
                                       mojo::GetProxy(&m_sink));
 }
 
-// Case 1: both canvas and compositor are not gpu accelerated.
+// Case 1: both canvas and compositor are not gpu accelerated, or canvas is
+// accelerated but --disable-gpu-compositing is specified, or
+// WebGL's commit called with swiftshader. The last case is indicated by
+// WebGraphicsContext3DProvider::isSoftwareRendering.
 void OffscreenCanvasFrameDispatcherImpl::setTransferableResourceInMemory(
     cc::TransferableResource& resource,
     RefPtr<StaticBitmapImage> image) {
   std::unique_ptr<cc::SharedBitmap> bitmap =
       Platform::current()->allocateSharedBitmap(IntSize(m_width, m_height));
   if (!bitmap)
     return;
   unsigned char* pixels = bitmap->pixels();
   DCHECK(pixels);
   SkImageInfo imageInfo = SkImageInfo::Make(
       m_width, m_height, kN32_SkColorType,
       image->isPremultiplied() ? kPremul_SkAlphaType : kUnpremul_SkAlphaType);
   // TODO(xlai): Optimize to avoid copying pixels. See crbug.com/651456.
+  // However, in the case when |image| is texture backed, this function call
+  // does a GPU readback which is required.
   image->imageForCurrentFrame()->readPixels(imageInfo, pixels,
                                             imageInfo.minRowBytes(), 0, 0);
   resource.mailbox_holder.mailbox = bitmap->id();
   resource.mailbox_holder.texture_target = 0;
   resource.is_software = true;
 
   // Hold ref to |bitmap|, to keep it alive until the browser ReturnResources.
   // It guarantees that the shared bitmap is not re-used or deleted.
   m_sharedBitmaps.add(m_nextResourceId, std::move(bitmap));
 }
@@ skipping 64 matching lines @@
       image->getMailbox(), image->getSyncToken(), GL_TEXTURE_2D);
   resource.read_lock_fences_enabled = false;
   resource.is_software = false;
 
   // Hold ref to |image|, to keep it alive until the browser ReturnResources.
   // It guarantees that the resource is not re-used or deleted.
   m_cachedImages.add(m_nextResourceId, std::move(image));
 }
 
 void OffscreenCanvasFrameDispatcherImpl::dispatchFrame(
-    RefPtr<StaticBitmapImage> image) {
+    RefPtr<StaticBitmapImage> image,
+    bool isWebGLSoftwareRendering) {
   if (!image)
     return;
   if (!verifyImageSize(image->imageForCurrentFrame()))
     return;
   cc::CompositorFrame frame;
+  // TODO(crbug.com/652931): update the device_scale_factor
   frame.metadata.device_scale_factor = 1.0f;
   frame.delegated_frame_data.reset(new cc::DelegatedFrameData);
 
   const gfx::Rect bounds(m_width, m_height);
   const cc::RenderPassId renderPassId(1, 1);
   std::unique_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
   pass->SetAll(renderPassId, bounds, bounds, gfx::Transform(), false);
 
   cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
   sqs->SetAll(gfx::Transform(), bounds.size(), bounds, bounds, false, 1.f,
               SkXfermode::kSrcOver_Mode, 0);
 
   cc::TransferableResource resource;
   resource.id = m_nextResourceId;
   resource.format = cc::ResourceFormat::RGBA_8888;
   // TODO(crbug.com/645590): filter should respect the image-rendering CSS
   // property of associated canvas element.
   resource.filter = GL_LINEAR;
   resource.size = gfx::Size(m_width, m_height);
   // TODO(crbug.com/646022): making this overlay-able.
   resource.is_overlay_candidate = false;
 
   if (!image->isTextureBacked() &&
       !RuntimeEnabledFeatures::gpuCompositingEnabled())
     setTransferableResourceInMemory(resource, image);
   else if (!image->isTextureBacked() &&
            RuntimeEnabledFeatures::gpuCompositingEnabled())
     setTransferableResourceMemoryToTexture(resource, image);
+  else if (image->isTextureBacked() &&
+           (!RuntimeEnabledFeatures::gpuCompositingEnabled() ||
+            isWebGLSoftwareRendering))

[Justin Novosad, 2016/10/05 15:38:56]

Could you add a comment that explains the rationale for Software rendered WebGL?

+    setTransferableResourceInMemory(resource, image);
   else
     setTransferableResourceInTexture(resource, image);
 
   m_nextResourceId++;
   frame.delegated_frame_data->resource_list.push_back(std::move(resource));
 
   cc::TextureDrawQuad* quad =
       pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
   gfx::Size rectSize(m_width, m_height);
 
@@ skipping 28 matching lines @@
 }
 
 bool OffscreenCanvasFrameDispatcherImpl::verifyImageSize(
     const sk_sp<SkImage>& image) {
   if (image && image->width() == m_width && image->height() == m_height)
     return true;
   return false;
 }
 
 }  // namespace blink