Revamp OffscreenCanvas commit flow

third_party/WebKit/Source/platform/graphics/CanvasSurfaceLayerBridge.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/CanvasSurfaceLayerBridge.h"
 
+#include "cc/layers/layer.h"
+#include "cc/layers/solid_color_layer.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/mojo/MojoHelper.h"
+#include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebLayer.h"
+#include "public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
 #include "ui/gfx/geometry/size.h"
 #include "wtf/Functional.h"
 
 namespace blink {
 
 CanvasSurfaceLayerBridge::CanvasSurfaceLayerBridge(
-    mojom::blink::OffscreenCanvasSurfacePtr service)
-    : m_service(std::move(service)) {}
+    CanvasSurfaceLayerBridgeObserver* observer)
+    : m_observer(observer),
+      m_binding(this),
+      m_frameSinkId(Platform::current()->generateFrameSinkId()) {
+  DCHECK(!m_service.is_bound());
+  mojom::blink::OffscreenCanvasSurfaceFactoryPtr serviceFactory;
+  Platform::current()->interfaceProvider()->getInterface(
+      mojo::GetProxy(&serviceFactory));
+  serviceFactory->CreateOffscreenCanvasSurface(
+      m_frameSinkId, m_binding.CreateInterfacePtrAndBind(),
+      mojo::GetProxy(&m_service));
+}
 
-CanvasSurfaceLayerBridge::~CanvasSurfaceLayerBridge() {}
+CanvasSurfaceLayerBridge::~CanvasSurfaceLayerBridge() {
+  m_observer = nullptr;
+}
 
-bool CanvasSurfaceLayerBridge::createSurfaceLayer(int canvasWidth,
-                                                  int canvasHeight) {
-  if (!m_service->GetSurfaceId(&m_surfaceId))
-    return false;
+void CanvasSurfaceLayerBridge::createSolidColorLayer() {
+  m_CCLayer = cc::SolidColorLayer::Create();
+  m_CCLayer->SetBackgroundColor(SK_ColorTRANSPARENT);
+  m_webLayer = Platform::current()->compositorSupport()->createLayerFromCCLayer(
+      m_CCLayer.get());
+  GraphicsLayer::registerContentsLayer(m_webLayer.get());
+}
 
-  cc::SurfaceLayer::SatisfyCallback satisfyCallback =
-      convertToBaseCallback(WTF::bind(
-          &CanvasSurfaceLayerBridge::satisfyCallback, WTF::unretained(this)));
-  cc::SurfaceLayer::RequireCallback requireCallback =
-      convertToBaseCallback(WTF::bind(
-          &CanvasSurfaceLayerBridge::requireCallback, WTF::unretained(this)));
-  m_surfaceLayer = cc::SurfaceLayer::Create(std::move(satisfyCallback),
-                                            std::move(requireCallback));
-  m_surfaceLayer->SetSurfaceId(m_surfaceId, 1.f,
-                               gfx::Size(canvasWidth, canvasHeight));
+void CanvasSurfaceLayerBridge::OnSurfaceCreated(const cc::SurfaceId& surfaceId,
+                                                int32_t width,

[jbauman, 2016/12/16 02:19:26]

I guess this could still glitch if the surface created callback is received and
the layer is added before the first frame for the surface is submitted?

[xlai (Olivia), 2016/12/16 21:34:06]

Nope this is impossible to happen. Only when the first frame of the surface is
submitted, then
the OffscreenCanvasCompositorFrameSink will start working and trigger Surface
creation, which
then trigger OffscreenCanvasSurfaceManager::OnSurfaceCreated as a Surface
observer, which will then finds the OffscreenCanvasSurfaceImpl that is
responsible in sending the surface created callback to here and the renderer
will respond by creating a SurfaceLayer.

+                                                int32_t height,
+                                                float deviceScaleFactor) {
+  if (!m_currentSurfaceId.is_valid() && surfaceId.is_valid()) {
+    m_currentSurfaceId = surfaceId;
+    GraphicsLayer::unregisterContentsLayer(m_webLayer.get());
+    m_webLayer->removeFromParent();
 
-  m_webLayer = Platform::current()->compositorSupport()->createLayerFromCCLayer(
-      m_surfaceLayer.get());
-  GraphicsLayer::registerContentsLayer(m_webLayer.get());
-  return true;
+    cc::SurfaceLayer::SatisfyCallback satisfyCallback =
+        convertToBaseCallback(WTF::bind(
+            &CanvasSurfaceLayerBridge::satisfyCallback, WTF::unretained(this)));
+    cc::SurfaceLayer::RequireCallback requireCallback =
+        convertToBaseCallback(WTF::bind(
+            &CanvasSurfaceLayerBridge::requireCallback, WTF::unretained(this)));
+    scoped_refptr<cc::SurfaceLayer> surfaceLayer = cc::SurfaceLayer::Create(
+        std::move(satisfyCallback), std::move(requireCallback));
+    surfaceLayer->SetSurfaceId(m_currentSurfaceId, deviceScaleFactor,

[Fady Samuel, 2016/12/15 22:55:51]

nit: TODO(xlai): Update this on resize.

[xlai (Olivia), 2016/12/16 21:34:06]

Done.

+                               gfx::Size(width, height));
+    m_CCLayer = surfaceLayer;
+
+    m_webLayer =
+        Platform::current()->compositorSupport()->createLayerFromCCLayer(
+            m_CCLayer.get());
+    GraphicsLayer::registerContentsLayer(m_webLayer.get());
+
+    m_observer->OnWebLayerReplaced();
+  }
 }
 
 void CanvasSurfaceLayerBridge::satisfyCallback(
     const cc::SurfaceSequence& sequence) {
   m_service->Satisfy(sequence);
 }
 
 void CanvasSurfaceLayerBridge::requireCallback(
     const cc::SurfaceId& surfaceId,
     const cc::SurfaceSequence& sequence) {
   m_service->Require(surfaceId, sequence);
 }
 
 }  // namespace blink