Remove CanvasSurfaceLayerBridgeClient

This was an abstraction so that tests could substitute in a fake
version of a Mojo interface in tests. However, the test can just
implement a testing version of the Mojo interface and use it
directly, simplifying the code.

BUG=none

Review-Url: https://codereview.chromium.org/2345423002
Cr-Commit-Position: refs/heads/master@{#420583}

third_party/WebKit/Source/core/html/HTMLCanvasElement.cpp

@@ -61,7 +61,6 @@
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/Canvas2DImageBufferSurface.h"
 #include "platform/graphics/CanvasMetrics.h"
-#include "platform/graphics/CanvasSurfaceLayerBridgeClientImpl.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/RecordingImageBufferSurface.h"
@@ -69,8 +68,10 @@
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
 #include "platform/transforms/AffineTransform.h"
+#include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
+#include "public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
 #include "wtf/CheckedNumeric.h"
 #include "wtf/PtrUtil.h"
 #include <math.h>
@@ -1288,8 +1289,9 @@ String HTMLCanvasElement::getIdFromControl(const Element* element)
 bool HTMLCanvasElement::createSurfaceLayer()
 {
     DCHECK(!m_surfaceLayerBridge);
-    std::unique_ptr<CanvasSurfaceLayerBridgeClient> bridgeClient = wrapUnique(new CanvasSurfaceLayerBridgeClientImpl());
-    m_surfaceLayerBridge = wrapUnique(new CanvasSurfaceLayerBridge(std::move(bridgeClient)));
+    mojom::blink::OffscreenCanvasSurfacePtr service;
+    Platform::current()->interfaceProvider()->getInterface(mojo::GetProxy(&service));
+    m_surfaceLayerBridge = wrapUnique(new CanvasSurfaceLayerBridge(std::move(service)));
     return m_surfaceLayerBridge->createSurfaceLayer(this->width(), this->height());
 }
 

third_party/WebKit/Source/platform/BUILD.gn

@@ -748,9 +748,6 @@ component("platform") {
     "graphics/CanvasMetrics.h",
     "graphics/CanvasSurfaceLayerBridge.cpp",
     "graphics/CanvasSurfaceLayerBridge.h",
-    "graphics/CanvasSurfaceLayerBridgeClient.h",
-    "graphics/CanvasSurfaceLayerBridgeClientImpl.cpp",
-    "graphics/CanvasSurfaceLayerBridgeClientImpl.h",
     "graphics/Color.cpp",
     "graphics/Color.h",
     "graphics/ColorSpace.cpp",

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

@@ -18,9 +18,9 @@
 
 namespace blink {
 
-CanvasSurfaceLayerBridge::CanvasSurfaceLayerBridge(std::unique_ptr<CanvasSurfaceLayerBridgeClient> client)
+CanvasSurfaceLayerBridge::CanvasSurfaceLayerBridge(mojom::blink::OffscreenCanvasSurfacePtr service)
+    : m_service(std::move(service))
 {
-    m_client = std::move(client);
 }
 
 CanvasSurfaceLayerBridge::~CanvasSurfaceLayerBridge()
@@ -29,7 +29,7 @@ CanvasSurfaceLayerBridge::~CanvasSurfaceLayerBridge()
 
 bool CanvasSurfaceLayerBridge::createSurfaceLayer(int canvasWidth, int canvasHeight)
 {
-    if (!m_client->syncGetSurfaceId(&m_surfaceId))
+    if (!m_service->GetSurfaceId(&m_surfaceId))
         return false;
 
     cc::SurfaceLayer::SatisfyCallback satisfyCallback = convertToBaseCallback(WTF::bind(&CanvasSurfaceLayerBridge::satisfyCallback, WTF::unretained(this)));
@@ -44,12 +44,12 @@ bool CanvasSurfaceLayerBridge::createSurfaceLayer(int canvasWidth, int canvasHei
 
 void CanvasSurfaceLayerBridge::satisfyCallback(const cc::SurfaceSequence& sequence)
 {
-    m_client->asyncSatisfy(sequence);
+    m_service->Satisfy(sequence);
 }
 
 void CanvasSurfaceLayerBridge::requireCallback(const cc::SurfaceId& surfaceId, const cc::SurfaceSequence& sequence)
 {
-    m_client->asyncRequire(surfaceId, sequence);
+    m_service->Require(surfaceId, sequence);
 }
 
 } // namespace blink

third_party/WebKit/Source/platform/graphics/CanvasSurfaceLayerBridge.h

@@ -8,7 +8,7 @@
 #include "base/memory/ref_counted.h"
 #include "cc/surfaces/surface_id.h"
 #include "platform/PlatformExport.h"
-#include "platform/graphics/CanvasSurfaceLayerBridgeClient.h"
+#include "public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
 #include <memory>
 
 namespace cc {
@@ -22,12 +22,11 @@ class WebLayer;
 
 class PLATFORM_EXPORT CanvasSurfaceLayerBridge {
 public:
-    explicit CanvasSurfaceLayerBridge(std::unique_ptr<CanvasSurfaceLayerBridgeClient>);
+    explicit CanvasSurfaceLayerBridge(mojom::blink::OffscreenCanvasSurfacePtr);
     ~CanvasSurfaceLayerBridge();
     bool createSurfaceLayer(int canvasWidth, int canvasHeight);
     WebLayer* getWebLayer() const { return m_webLayer.get(); }
     const cc::SurfaceId& getSurfaceId() const { return m_surfaceId; }
-    CanvasSurfaceLayerBridgeClient* getClient() const { return m_client.get(); }
 
     void satisfyCallback(const cc::SurfaceSequence&);
     void requireCallback(const cc::SurfaceId&, const cc::SurfaceSequence&);
@@ -35,7 +34,7 @@ public:
 private:
     scoped_refptr<cc::SurfaceLayer> m_surfaceLayer;
     std::unique_ptr<WebLayer> m_webLayer;
-    std::unique_ptr<CanvasSurfaceLayerBridgeClient> m_client;
+    mojom::blink::OffscreenCanvasSurfacePtr m_service;
     cc::SurfaceId m_surfaceId;
 };
 

third_party/WebKit/Source/platform/graphics/CanvasSurfaceLayerBridgeClient.h

-// 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.
-
-#ifndef CanvasSurfaceLayerBridgeClient_h
-#define CanvasSurfaceLayerBridgeClient_h
-
-#include "cc/surfaces/surface_id.h"
-#include "cc/surfaces/surface_sequence.h"
-#include "platform/PlatformExport.h"
-
-namespace blink {
-
-// This class is an interface for all mojo calls from CanvasSurfaceLayerBridge
-// to OffscreenCanvasSurfaceService.
-class PLATFORM_EXPORT CanvasSurfaceLayerBridgeClient {
-public:
-    virtual ~CanvasSurfaceLayerBridgeClient() {};
-
-    // Calls that help initial creation of SurfaceLayer.
-    virtual bool syncGetSurfaceId(cc::SurfaceId*) = 0;
-
-    // Calls that ensure correct destruction order of surface.
-    virtual void asyncRequire(const cc::SurfaceId&, const cc::SurfaceSequence&) = 0;
-    virtual void asyncSatisfy(const cc::SurfaceSequence&) = 0;
-};
-
-} // namespace blink
-
-#endif // CanvasSurfaceLayerBridgeClient_h

third_party/WebKit/Source/platform/graphics/CanvasSurfaceLayerBridgeClientImpl.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/CanvasSurfaceLayerBridgeClientImpl.h"
-
-#include "public/platform/InterfaceProvider.h"
-#include "public/platform/Platform.h"
-
-namespace blink {
-
-CanvasSurfaceLayerBridgeClientImpl::CanvasSurfaceLayerBridgeClientImpl()
-{
-    DCHECK(!m_service.is_bound());
-    Platform::current()->interfaceProvider()->getInterface(mojo::GetProxy(&m_service));
-}
-
-CanvasSurfaceLayerBridgeClientImpl::~CanvasSurfaceLayerBridgeClientImpl()
-{
-}
-
-bool CanvasSurfaceLayerBridgeClientImpl::syncGetSurfaceId(cc::SurfaceId* surfaceIdPtr)
-{
-    return m_service->GetSurfaceId(surfaceIdPtr);
-}
-
-void CanvasSurfaceLayerBridgeClientImpl::asyncRequire(const cc::SurfaceId& surfaceId, const cc::SurfaceSequence& sequence)
-{
-    m_service->Require(surfaceId, sequence);
-}
-
-void CanvasSurfaceLayerBridgeClientImpl::asyncSatisfy(const cc::SurfaceSequence& sequence)
-{
-    m_service->Satisfy(sequence);
-}
-
-} // namespace blink;

third_party/WebKit/Source/platform/graphics/CanvasSurfaceLayerBridgeClientImpl.h

-// 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.
-
-#ifndef CanvasSurfaceLayerBridgeClientImpl_h
-#define CanvasSurfaceLayerBridgeClientImpl_h
-
-#include "platform/graphics/CanvasSurfaceLayerBridgeClient.h"
-#include "public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
-#include "wtf/RefPtr.h"
-
-namespace blink {
-
-class PLATFORM_EXPORT CanvasSurfaceLayerBridgeClientImpl final : public CanvasSurfaceLayerBridgeClient {
-public:
-    explicit CanvasSurfaceLayerBridgeClientImpl();
-    ~CanvasSurfaceLayerBridgeClientImpl() override;
-
-    bool syncGetSurfaceId(cc::SurfaceId*) override;
-    void asyncRequire(const cc::SurfaceId&, const cc::SurfaceSequence&) override;
-    void asyncSatisfy(const cc::SurfaceSequence&) override;
-
-private:
-    mojom::blink::OffscreenCanvasSurfacePtr m_service;
-};
-
-} // namespace blink
-
-#endif // CanvasSurfaceLayerBridgeClientImpl_h

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

@@ -6,7 +6,9 @@
 
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_sequence.h"
-#include "platform/graphics/CanvasSurfaceLayerBridgeClient.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+#include "public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom-blink.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
@@ -14,27 +16,21 @@
 
 namespace blink {
 
-class FakeOffscreenCanvasSurfaceImpl {
-public:
-    FakeOffscreenCanvasSurfaceImpl() {}
-    ~FakeOffscreenCanvasSurfaceImpl() {}
-
-    bool GetSurfaceId(cc::SurfaceId*);
-};
-
 //-----------------------------------------------------------------------------
 
-class MockCanvasSurfaceLayerBridgeClient final : public CanvasSurfaceLayerBridgeClient {
+class MockOffscreenCanvasSurface final : public mojom::blink::OffscreenCanvasSurface {
 public:
-    explicit MockCanvasSurfaceLayerBridgeClient(FakeOffscreenCanvasSurfaceImpl*);
-    ~MockCanvasSurfaceLayerBridgeClient() override;
+    MockOffscreenCanvasSurface();
+    ~MockOffscreenCanvasSurface() override;
+
+    mojom::blink::OffscreenCanvasSurfacePtr GetProxy();
 
-    bool syncGetSurfaceId(cc::SurfaceId*) override;
-    void asyncRequire(const cc::SurfaceId&, const cc::SurfaceSequence&) override {}
-    void asyncSatisfy(const cc::SurfaceSequence&) override {}
+    void GetSurfaceId(const GetSurfaceIdCallback&) override;
+    void Require(const cc::SurfaceId&, const cc::SurfaceSequence&) override {}
+    void Satisfy(const cc::SurfaceSequence&) override {}
 
 private:
-    FakeOffscreenCanvasSurfaceImpl* m_service;
+    mojo::Binding<mojom::blink::OffscreenCanvasSurface> m_binding;
     cc::SurfaceId m_surfaceId;
 };
 
@@ -43,43 +39,39 @@ private:
 class CanvasSurfaceLayerBridgeTest : public testing::Test {
 public:
     CanvasSurfaceLayerBridge* surfaceLayerBridge() const { return m_surfaceLayerBridge.get(); }
-    FakeOffscreenCanvasSurfaceImpl* surfaceService() const { return m_surfaceService.get(); }
 
 protected:
     void SetUp() override;
 
 private:
-    std::unique_ptr<FakeOffscreenCanvasSurfaceImpl> m_surfaceService;
+    MockOffscreenCanvasSurface m_service;
     std::unique_ptr<CanvasSurfaceLayerBridge> m_surfaceLayerBridge;
 };
 
 //-----------------------------------------------------------------------------
 
-MockCanvasSurfaceLayerBridgeClient::MockCanvasSurfaceLayerBridgeClient(FakeOffscreenCanvasSurfaceImpl* surfaceService)
+MockOffscreenCanvasSurface::MockOffscreenCanvasSurface()
+    : m_binding(this)
 {
-    m_service = surfaceService;
 }
 
-MockCanvasSurfaceLayerBridgeClient::~MockCanvasSurfaceLayerBridgeClient()
+MockOffscreenCanvasSurface::~MockOffscreenCanvasSurface()
 {
 }
 
-bool MockCanvasSurfaceLayerBridgeClient::syncGetSurfaceId(cc::SurfaceId* surfaceIdPtr)
+mojom::blink::OffscreenCanvasSurfacePtr MockOffscreenCanvasSurface::GetProxy()
 {
-    return m_service->GetSurfaceId(surfaceIdPtr);
+    return m_binding.CreateInterfacePtrAndBind();
 }
 
-bool FakeOffscreenCanvasSurfaceImpl::GetSurfaceId(cc::SurfaceId* surfaceId)
+void MockOffscreenCanvasSurface::GetSurfaceId(const GetSurfaceIdCallback& callback)
 {
-    *surfaceId = cc::SurfaceId(10, 15, 0);
-    return true;
+    callback.Run(cc::SurfaceId(10, 15, 0));
 }
 
 void CanvasSurfaceLayerBridgeTest::SetUp()
 {
-    m_surfaceService = wrapUnique(new FakeOffscreenCanvasSurfaceImpl());
-    std::unique_ptr<CanvasSurfaceLayerBridgeClient> bridgeClient = wrapUnique(new MockCanvasSurfaceLayerBridgeClient(m_surfaceService.get()));
-    m_surfaceLayerBridge = wrapUnique(new CanvasSurfaceLayerBridge(std::move(bridgeClient)));
+    m_surfaceLayerBridge = wrapUnique(new CanvasSurfaceLayerBridge(m_service.GetProxy()));
 }
 
 TEST_F(CanvasSurfaceLayerBridgeTest, SurfaceLayerCreation)