Implement WebGL's commit on the main thread

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"
 #include "cc/quads/solid_color_draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
+#include "platform/graphics/StaticBitmapImage.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
+#include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/transform.h"
 
 namespace blink {
 
 OffscreenCanvasFrameDispatcherImpl::OffscreenCanvasFrameDispatcherImpl(uint32_t clientId, uint32_t localId, uint64_t nonce, int width, int height)
     : m_surfaceId(cc::SurfaceId(clientId, localId, nonce))
     , m_width(width)
     , m_height(height)
 {
     DCHECK(!m_service.is_bound());
     Platform::current()->interfaceProvider()->getInterface(mojo::GetProxy(&m_service));
 }
 
-void OffscreenCanvasFrameDispatcherImpl::dispatchFrame()
+void OffscreenCanvasFrameDispatcherImpl::dispatchFrame(PassRefPtr<StaticBitmapImage> image)
 {
-    // TODO(563852/xlai): Currently this is just a simple solid-color compositor
-    // frame. We need to update this function to extract the image data from canvas.
     cc::CompositorFrame frame;
     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::SolidColorDrawQuad* quad = pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
-    const bool forceAntialiasingOff = false;
-    quad->SetNew(sqs, bounds, bounds, SK_ColorGREEN, forceAntialiasingOff);
+    // TODO(xidachen): for now, we just submit a SolidColor frame to compositor in the 2d case,
+    // we should extract data from image.
+    if (!image) {
+        cc::SolidColorDrawQuad* quad = pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
+        const bool forceAntialiasingOff = false;
+        quad->SetNew(sqs, bounds, bounds, SK_ColorGREEN, forceAntialiasingOff);
+    } else { // WebGL
+        DCHECK(image->isTextureBacked());
+        cc::TransferableResource resource;
+        resource.id = image->getTextureId();

[danakj, 2016/09/09 20:51:42]

The id is not the texture id, it's a ResourceId from ResourceProvider. You can
just invent a unique ID if you don't want to use ResourceProvider. The browser
will use that number when giving the resource back so you can find it again.

This probably means you don't need a texture id in any of the staticbitmapimage
stuff.

Also, speaking of, where is the browser returning resources? Are you keeping the
resource alive while the browser has it somehow? Where are we keeping the
|image| alive until then?

Did you decide not to use ResourceProvider for a specific reason? It helps with
these things.

+        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);
+        resource.mailbox_holder = gpu::MailboxHolder(image->getMailbox(), image->getSyncToken(), GL_TEXTURE_2D);
+        resource.read_lock_fences_enabled = false;
+        resource.is_software = false;
+        resource.is_overlay_candidate = false;

[danakj, 2016/09/09 20:51:42]

Maybe TODO to make these overlay-able?

[Ken Russell (switch to Gerrit), 2016/09/09 21:38:17]

Second that notion -- it'd be ideal to have these canvases go down the same
compositing path as normally-rendered HTMLCanvasElements. Fine to do this as a
TODO.

The fact that the canvas element had transferControlToOffscreen called on it
should be a good hint that OffscreenCanvas should use the CHROMIUM_image
allocation path (which I assume is needed for this resource to be promoted to an
overlay) for its color buffer.

+        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);
+
+        const bool needsBlending = true;
+        const bool premultipliedAlpha = true;

[Ken Russell (switch to Gerrit), 2016/09/09 21:38:17]

Is there a TODO to inherit this from the WebGL context's creation settings?

+        const gfx::PointF uvTopLeft(0.f, 0.f);
+        const gfx::PointF uvBottomRight(1.f, 1.f);
+        float vertexOpacity[4] = {1.f, 1.f, 1.f, 1.f};
+        const bool yflipped = false;
+        // TODO(xidachen): this should be true when using style "image-rendering: pixelated".
+        const bool nearestNeighbor = false;
+        quad->SetAll(sqs, bounds, bounds, bounds, needsBlending, resource.id, gfx::Size(), premultipliedAlpha,
+            uvTopLeft, uvBottomRight, SK_ColorTRANSPARENT, vertexOpacity, yflipped, nearestNeighbor, false);
+    }
 
     frame.delegated_frame_data->render_pass_list.push_back(std::move(pass));
 
     m_service->SubmitCompositorFrame(m_surfaceId, std::move(frame));
 }
 
 } // namespace blink