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
+        cc::TransferableResource resource;

[Justin Novosad, 2016/09/09 19:10:51]

Here, we should probably assert that 'image' is gpu-backed

[xidachen, 2016/09/09 19:23:42]

Done.

+        resource.id = image->getTextureId();

[Justin Novosad, 2016/09/09 19:10:50]

I suspect is wrong.  The texture Id is useless outside of the GL context it
belongs to. Are you sure this is what the resource.id field is meant to be used
for?

[xidachen, 2016/09/09 19:23:42]

I am not very sure. I looked at this example:
https://cs.chromium.org/chromium/src/services/ui/demo/bitmap_uploader.cc?q=bi...

In the above example, it kept textureId in a hash map, and call
gl->DeleteTextures(1, &texture_id); in a OnResourcesReturned() function call.

danakj@: comments?

+        resource.format = cc::ResourceFormat::RGBA_8888;

[Justin Novosad, 2016/09/09 19:10:51]

we should be extracting format from 'image' instead of using a hard coded value.

[xidachen, 2016/09/09 19:23:42]

My impression was that this mailbox is a resource from GPU, and that is always
in RGBA_8888 format?

+        resource.filter = GL_LINEAR;

[Justin Novosad, 2016/09/09 19:10:51]

Please add a TODO and create a crbug for this: the filter needs to respect the
image-rendering CSS property of the associated canvas element.

[xidachen, 2016/09/09 19:23:42]

Done.

+        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;
+        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;
+        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;
+        const bool nearestNeighbor = false;

[Justin Novosad, 2016/09/09 19:10:50]

TODO: needs to be true when using style "image-rendering: pixelated"

[xidachen, 2016/09/09 19:23:42]

Done.

+        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