2 files changed, 66 insertions, 85 deletions

diff --git a/chromium/content/renderer/android/synchronous_layer_tree_frame_sink.cc b/chromium/content/renderer/android/synchronous_layer_tree_frame_sink_impl.cc
index d002a87ab24..e8d7c94e41e 100644
--- a/chromium/content/renderer/android/synchronous_layer_tree_frame_sink.cc
+++ b/chromium/content/renderer/android/synchronous_layer_tree_frame_sink_impl.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/renderer/android/synchronous_layer_tree_frame_sink.h"
+#include "content/renderer/android/synchronous_layer_tree_frame_sink_impl.h"
 
 #include <vector>
 
@@ -100,7 +100,7 @@ class SoftwareCompositorFrameSinkClient
 
 }  // namespace
 
-class SynchronousLayerTreeFrameSink::SoftwareOutputSurface
+class SynchronousLayerTreeFrameSinkImpl::SoftwareOutputSurface
     : public viz::OutputSurface {
  public:
   SoftwareOutputSurface(std::unique_ptr<SoftwareDevice> software_device)
@@ -137,20 +137,19 @@ class SynchronousLayerTreeFrameSink::SoftwareOutputSurface
   gpu::MemoryTracker* GetMemoryTracker() override { return nullptr; }
 };
 
-base::TimeDelta SynchronousLayerTreeFrameSink::StubDisplayClient::
+base::TimeDelta SynchronousLayerTreeFrameSinkImpl::StubDisplayClient::
     GetPreferredFrameIntervalForFrameSinkId(
         const viz::FrameSinkId& id,
         viz::mojom::CompositorFrameSinkType* type) {
   return viz::BeginFrameArgs::MinInterval();
 }
 
-SynchronousLayerTreeFrameSink::SynchronousLayerTreeFrameSink(
+SynchronousLayerTreeFrameSinkImpl::SynchronousLayerTreeFrameSinkImpl(
     scoped_refptr<viz::ContextProvider> context_provider,
     scoped_refptr<viz::RasterContextProvider> worker_context_provider,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     IPC::Sender* sender,
-    int routing_id,
     uint32_t layer_tree_frame_sink_id,
     std::unique_ptr<viz::BeginFrameSource> synthetic_begin_frame_source,
     SynchronousCompositorRegistry* registry,
@@ -159,11 +158,10 @@ SynchronousLayerTreeFrameSink::SynchronousLayerTreeFrameSink(
         compositor_frame_sink_remote,
     mojo::PendingReceiver<viz::mojom::CompositorFrameSinkClient>
         client_receiver)
-    : cc::LayerTreeFrameSink(std::move(context_provider),
-                             std::move(worker_context_provider),
-                             std::move(compositor_task_runner),
-                             gpu_memory_buffer_manager),
-      routing_id_(routing_id),
+    : SynchronousLayerTreeFrameSink(std::move(context_provider),
+                                    std::move(worker_context_provider),
+                                    std::move(compositor_task_runner),
+                                    gpu_memory_buffer_manager),
       layer_tree_frame_sink_id_(layer_tree_frame_sink_id),
       registry_(registry),
       sender_(sender),
@@ -181,14 +179,15 @@ SynchronousLayerTreeFrameSink::SynchronousLayerTreeFrameSink(
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
 
-SynchronousLayerTreeFrameSink::~SynchronousLayerTreeFrameSink() = default;
+SynchronousLayerTreeFrameSinkImpl::~SynchronousLayerTreeFrameSinkImpl() =
+    default;
 
-void SynchronousLayerTreeFrameSink::SetSyncClient(
+void SynchronousLayerTreeFrameSinkImpl::SetSyncClient(
     SynchronousLayerTreeFrameSinkClient* compositor) {
   sync_client_ = compositor;
 }
 
-bool SynchronousLayerTreeFrameSink::BindToClient(
+bool SynchronousLayerTreeFrameSinkImpl::BindToClient(
     cc::LayerTreeFrameSinkClient* sink_client) {
   DCHECK(CalledOnValidThread());
   if (!cc::LayerTreeFrameSink::BindToClient(sink_client))
@@ -216,9 +215,9 @@ bool SynchronousLayerTreeFrameSink::BindToClient(
 
   client_->SetMemoryPolicy(memory_policy_);
   client_->SetTreeActivationCallback(base::BindRepeating(
-      &SynchronousLayerTreeFrameSink::DidActivatePendingTree,
+      &SynchronousLayerTreeFrameSinkImpl::DidActivatePendingTree,
       base::Unretained(this)));
-  registry_->RegisterLayerTreeFrameSink(routing_id_, this);
+  registry_->RegisterLayerTreeFrameSink(this);
 
   software_frame_sink_client_ =
       std::make_unique<SoftwareCompositorFrameSinkClient>();
@@ -256,7 +255,7 @@ bool SynchronousLayerTreeFrameSink::BindToClient(
   return true;
 }
 
-void SynchronousLayerTreeFrameSink::DetachFromClient() {
+void SynchronousLayerTreeFrameSinkImpl::DetachFromClient() {
   DCHECK(CalledOnValidThread());
   client_->SetBeginFrameSource(nullptr);
   // Destroy the begin frame source on the same thread it was bound on.
@@ -264,7 +263,7 @@ void SynchronousLayerTreeFrameSink::DetachFromClient() {
   external_begin_frame_source_ = nullptr;
   if (sync_client_)
     sync_client_->SinkDestroyed();
-  registry_->UnregisterLayerTreeFrameSink(routing_id_, this);
+  registry_->UnregisterLayerTreeFrameSink(this);
   client_->SetTreeActivationCallback(base::RepeatingClosure());
   root_support_.reset();
   child_support_.reset();
@@ -279,13 +278,13 @@ void SynchronousLayerTreeFrameSink::DetachFromClient() {
   cc::LayerTreeFrameSink::DetachFromClient();
 }
 
-void SynchronousLayerTreeFrameSink::SetLocalSurfaceId(
+void SynchronousLayerTreeFrameSinkImpl::SetLocalSurfaceId(
     const viz::LocalSurfaceId& local_surface_id) {
   DCHECK(CalledOnValidThread());
   local_surface_id_ = local_surface_id;
 }
 
-void SynchronousLayerTreeFrameSink::SubmitCompositorFrame(
+void SynchronousLayerTreeFrameSinkImpl::SubmitCompositorFrame(
     viz::CompositorFrame frame,
     bool hit_test_data_changed,
     bool show_hit_test_borders) {
@@ -419,14 +418,14 @@ void SynchronousLayerTreeFrameSink::SubmitCompositorFrame(
   did_submit_frame_ = true;
 }
 
-void SynchronousLayerTreeFrameSink::DidNotProduceFrame(
+void SynchronousLayerTreeFrameSinkImpl::DidNotProduceFrame(
     const viz::BeginFrameAck& ack) {
   // We do not call CompositorFrameSink::DidNotProduceFrame here because
   // submission of frame depends on DemandDraw calls. DidNotProduceFrame will be
   // called there or during OnBeginFrame as fallback.
 }
 
-void SynchronousLayerTreeFrameSink::DidAllocateSharedBitmap(
+void SynchronousLayerTreeFrameSinkImpl::DidAllocateSharedBitmap(
     base::ReadOnlySharedMemoryRegion region,
     const viz::SharedBitmapId& id) {
   // Webview does not use software compositing (other than resourceless draws,
@@ -434,20 +433,20 @@ void SynchronousLayerTreeFrameSink::DidAllocateSharedBitmap(
   NOTREACHED();
 }
 
-void SynchronousLayerTreeFrameSink::DidDeleteSharedBitmap(
+void SynchronousLayerTreeFrameSinkImpl::DidDeleteSharedBitmap(
     const viz::SharedBitmapId& id) {
   // Webview does not use software compositing (other than resourceless draws,
   // but this is called for software /resources/).
   NOTREACHED();
 }
 
-void SynchronousLayerTreeFrameSink::Invalidate(bool needs_draw) {
+void SynchronousLayerTreeFrameSinkImpl::Invalidate(bool needs_draw) {
   DCHECK(CalledOnValidThread());
   if (sync_client_)
     sync_client_->Invalidate(needs_draw);
 }
 
-void SynchronousLayerTreeFrameSink::DemandDrawHw(
+void SynchronousLayerTreeFrameSinkImpl::DemandDrawHw(
     const gfx::Size& viewport_size,
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
@@ -460,7 +459,7 @@ void SynchronousLayerTreeFrameSink::DemandDrawHw(
   InvokeComposite(gfx::Transform(), gfx::Rect(viewport_size));
 }
 
-void SynchronousLayerTreeFrameSink::DemandDrawSw(SkCanvas* canvas) {
+void SynchronousLayerTreeFrameSinkImpl::DemandDrawSw(SkCanvas* canvas) {
   DCHECK(CalledOnValidThread());
   DCHECK(canvas);
   DCHECK(!current_sw_canvas_);
@@ -481,12 +480,12 @@ void SynchronousLayerTreeFrameSink::DemandDrawSw(SkCanvas* canvas) {
   InvokeComposite(transform, viewport);
 }
 
-void SynchronousLayerTreeFrameSink::WillSkipDraw() {
+void SynchronousLayerTreeFrameSinkImpl::WillSkipDraw() {
   client_->OnDraw(gfx::Transform(), gfx::Rect(), in_software_draw_,
                   true /*skip_draw*/);
 }
 
-void SynchronousLayerTreeFrameSink::InvokeComposite(
+void SynchronousLayerTreeFrameSinkImpl::InvokeComposite(
     const gfx::Transform& transform,
     const gfx::Rect& viewport) {
   did_submit_frame_ = false;
@@ -508,7 +507,7 @@ void SynchronousLayerTreeFrameSink::InvokeComposite(
   }
 }
 
-void SynchronousLayerTreeFrameSink::ReclaimResources(
+void SynchronousLayerTreeFrameSinkImpl::ReclaimResources(
     uint32_t layer_tree_frame_sink_id,
     const std::vector<viz::ReturnedResource>& resources) {
   // Ignore message if it's a stale one coming from a different output surface
@@ -518,7 +517,7 @@ void SynchronousLayerTreeFrameSink::ReclaimResources(
   client_->ReclaimResources(resources);
 }
 
-void SynchronousLayerTreeFrameSink::SetMemoryPolicy(size_t bytes_limit) {
+void SynchronousLayerTreeFrameSinkImpl::SetMemoryPolicy(size_t bytes_limit) {
   DCHECK(CalledOnValidThread());
   bool became_zero = memory_policy_.bytes_limit_when_visible && !bytes_limit;
   bool became_non_zero =
@@ -540,14 +539,14 @@ void SynchronousLayerTreeFrameSink::SetMemoryPolicy(size_t bytes_limit) {
   }
 }
 
-void SynchronousLayerTreeFrameSink::DidActivatePendingTree() {
+void SynchronousLayerTreeFrameSinkImpl::DidActivatePendingTree() {
   DCHECK(CalledOnValidThread());
   if (sync_client_)
     sync_client_->DidActivatePendingTree();
   DeliverMessages();
 }
 
-void SynchronousLayerTreeFrameSink::DeliverMessages() {
+void SynchronousLayerTreeFrameSinkImpl::DeliverMessages() {
   std::vector<std::unique_ptr<IPC::Message>> messages;
   std::unique_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
       frame_swap_message_queue_->AcquireSendMessageScope();
@@ -557,16 +556,16 @@ void SynchronousLayerTreeFrameSink::DeliverMessages() {
   }
 }
 
-bool SynchronousLayerTreeFrameSink::Send(IPC::Message* message) {
+bool SynchronousLayerTreeFrameSinkImpl::Send(IPC::Message* message) {
   DCHECK(CalledOnValidThread());
   return sender_->Send(message);
 }
 
-bool SynchronousLayerTreeFrameSink::CalledOnValidThread() const {
+bool SynchronousLayerTreeFrameSinkImpl::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
-void SynchronousLayerTreeFrameSink::DidReceiveCompositorFrameAck(
+void SynchronousLayerTreeFrameSinkImpl::DidReceiveCompositorFrameAck(
     const std::vector<viz::ReturnedResource>& resources) {
   DCHECK(CalledOnValidThread());
   DCHECK(viz_frame_submission_enabled_);
@@ -576,7 +575,7 @@ void SynchronousLayerTreeFrameSink::DidReceiveCompositorFrameAck(
   // (or not happen at all) for WebView.
 }
 
-void SynchronousLayerTreeFrameSink::OnBeginFrame(
+void SynchronousLayerTreeFrameSinkImpl::OnBeginFrame(
     const viz::BeginFrameArgs& args,
     const viz::FrameTimingDetailsMap& timing_details) {
   DCHECK(viz_frame_submission_enabled_);
@@ -592,18 +591,18 @@ void SynchronousLayerTreeFrameSink::OnBeginFrame(
   }
 }
 
-void SynchronousLayerTreeFrameSink::ReclaimResources(
+void SynchronousLayerTreeFrameSinkImpl::ReclaimResources(
     const std::vector<viz::ReturnedResource>& resources) {
   DCHECK(CalledOnValidThread());
   DCHECK(viz_frame_submission_enabled_);
   client_->ReclaimResources(resources);
 }
 
-void SynchronousLayerTreeFrameSink::OnBeginFramePausedChanged(bool paused) {
+void SynchronousLayerTreeFrameSinkImpl::OnBeginFramePausedChanged(bool paused) {
   DCHECK(viz_frame_submission_enabled_);
 }
 
-void SynchronousLayerTreeFrameSink::OnNeedsBeginFrames(
+void SynchronousLayerTreeFrameSinkImpl::OnNeedsBeginFrames(
     bool needs_begin_frames) {
   needs_begin_frames_ = needs_begin_frames;
   if (sync_client_) {
@@ -611,7 +610,7 @@ void SynchronousLayerTreeFrameSink::OnNeedsBeginFrames(
   }
 }
 
-void SynchronousLayerTreeFrameSink::DidPresentCompositorFrame(
+void SynchronousLayerTreeFrameSinkImpl::DidPresentCompositorFrame(
     const viz::FrameTimingDetailsMap& timing_details) {
   DCHECK(!viz_frame_submission_enabled_ || timing_details.empty());
 
@@ -621,13 +620,13 @@ void SynchronousLayerTreeFrameSink::DidPresentCompositorFrame(
     client_->DidPresentCompositorFrame(pair.first, pair.second);
 }
 
-void SynchronousLayerTreeFrameSink::BeginFrame(
+void SynchronousLayerTreeFrameSinkImpl::BeginFrame(
     const viz::BeginFrameArgs& args) {
   if (external_begin_frame_source_)
     external_begin_frame_source_->OnBeginFrame(args);
 }
 
-void SynchronousLayerTreeFrameSink::SetBeginFrameSourcePaused(bool paused) {
+void SynchronousLayerTreeFrameSinkImpl::SetBeginFrameSourcePaused(bool paused) {
   if (external_begin_frame_source_)
     external_begin_frame_source_->OnSetBeginFrameSourcePaused(paused);
 }
diff --git a/chromium/content/renderer/android/synchronous_layer_tree_frame_sink.h b/chromium/content/renderer/android/synchronous_layer_tree_frame_sink_impl.h
index 8e2a2c39220..9a2aa507669 100644
--- a/chromium/content/renderer/android/synchronous_layer_tree_frame_sink.h
+++ b/chromium/content/renderer/android/synchronous_layer_tree_frame_sink_impl.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_RENDERER_ANDROID_SYNCHRONOUS_LAYER_TREE_FRAME_SINK_H_
-#define CONTENT_RENDERER_ANDROID_SYNCHRONOUS_LAYER_TREE_FRAME_SINK_H_
+#ifndef CONTENT_RENDERER_ANDROID_SYNCHRONOUS_LAYER_TREE_FRAME_SINK_IMPL_H_
+#define CONTENT_RENDERER_ANDROID_SYNCHRONOUS_LAYER_TREE_FRAME_SINK_IMPL_H_
 
 #include <stddef.h>
 
@@ -26,6 +26,7 @@
 #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
 #include "components/viz/service/display/display_client.h"
 #include "components/viz/service/display_embedder/server_shared_bitmap_manager.h"
+#include "content/renderer/input/synchronous_layer_tree_frame_sink.h"
 #include "ipc/ipc_message.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
@@ -54,21 +55,6 @@ namespace content {
 class FrameSwapMessageQueue;
 class SynchronousCompositorRegistry;
 
-class SynchronousLayerTreeFrameSinkClient {
- public:
-  virtual void DidActivatePendingTree() = 0;
-  virtual void Invalidate(bool needs_draw) = 0;
-  virtual void SubmitCompositorFrame(
-      uint32_t layer_tree_frame_sink_id,
-      base::Optional<viz::CompositorFrame> frame,
-      base::Optional<viz::HitTestRegionList> hit_test_region_list) = 0;
-  virtual void SetNeedsBeginFrames(bool needs_begin_frames) = 0;
-  virtual void SinkDestroyed() = 0;
-
- protected:
-  virtual ~SynchronousLayerTreeFrameSinkClient() {}
-};
-
 // Specialization of the output surface that adapts it to implement the
 // content::SynchronousCompositor public API. This class effects an "inversion
 // of control" - enabling drawing to be  orchestrated by the embedding
@@ -77,18 +63,17 @@ class SynchronousLayerTreeFrameSinkClient {
 // |delegate_|) which represent the consumers of the two roles in plays.
 // This class can be created only on the main thread, but then becomes pinned
 // to a fixed thread when BindToClient is called.
-class SynchronousLayerTreeFrameSink
-    : public cc::LayerTreeFrameSink,
+class SynchronousLayerTreeFrameSinkImpl
+    : public SynchronousLayerTreeFrameSink,
       public viz::mojom::CompositorFrameSinkClient,
       public viz::ExternalBeginFrameSourceClient {
  public:
-  SynchronousLayerTreeFrameSink(
+  SynchronousLayerTreeFrameSinkImpl(
       scoped_refptr<viz::ContextProvider> context_provider,
       scoped_refptr<viz::RasterContextProvider> worker_context_provider,
       scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       IPC::Sender* sender,
-      int routing_id,
       uint32_t layer_tree_frame_sink_id,
       std::unique_ptr<viz::BeginFrameSource> begin_frame_source,
       SynchronousCompositorRegistry* registry,
@@ -97,9 +82,7 @@ class SynchronousLayerTreeFrameSink
           compositor_frame_sink_remote,
       mojo::PendingReceiver<viz::mojom::CompositorFrameSinkClient>
           client_receiver);
-  ~SynchronousLayerTreeFrameSink() override;
-
-  void SetSyncClient(SynchronousLayerTreeFrameSinkClient* compositor);
+  ~SynchronousLayerTreeFrameSinkImpl() override;
 
   // cc::LayerTreeFrameSink implementation.
   bool BindToClient(cc::LayerTreeFrameSinkClient* sink_client) override;
@@ -114,13 +97,6 @@ class SynchronousLayerTreeFrameSink
   void DidDeleteSharedBitmap(const viz::SharedBitmapId& id) override;
   void Invalidate(bool needs_draw) override;
 
-  // Partial SynchronousCompositor API implementation.
-  void DemandDrawHw(const gfx::Size& viewport_size,
-                    const gfx::Rect& viewport_rect_for_tile_priority,
-                    const gfx::Transform& transform_for_tile_priority);
-  void DemandDrawSw(SkCanvas* canvas);
-  void WillSkipDraw();
-
   // viz::mojom::CompositorFrameSinkClient implementation.
   void DidReceiveCompositorFrameAck(
       const std::vector<viz::ReturnedResource>& resources) override;
@@ -133,13 +109,21 @@ class SynchronousLayerTreeFrameSink
   // viz::ExternalBeginFrameSourceClient overrides.
   void OnNeedsBeginFrames(bool needs_begin_frames) override;
 
+  // SynchronousLayerTreeFrameSink overrides.
+  void SetSyncClient(SynchronousLayerTreeFrameSinkClient* compositor) override;
   void DidPresentCompositorFrame(
-      const viz::FrameTimingDetailsMap& timing_details);
-  void BeginFrame(const viz::BeginFrameArgs& args);
-  void SetBeginFrameSourcePaused(bool paused);
-  void SetMemoryPolicy(size_t bytes_limit);
-  void ReclaimResources(uint32_t layer_tree_frame_sink_id,
-                        const std::vector<viz::ReturnedResource>& resources);
+      const viz::FrameTimingDetailsMap& timing_details) override;
+  void BeginFrame(const viz::BeginFrameArgs& args) override;
+  void SetBeginFrameSourcePaused(bool paused) override;
+  void SetMemoryPolicy(size_t bytes_limit) override;
+  void ReclaimResources(
+      uint32_t layer_tree_frame_sink_id,
+      const std::vector<viz::ReturnedResource>& resources) override;
+  void DemandDrawHw(const gfx::Size& viewport_size,
+                    const gfx::Rect& viewport_rect_for_tile_priority,
+                    const gfx::Transform& transform_for_tile_priority) override;
+  void DemandDrawSw(SkCanvas* canvas) override;
+  void WillSkipDraw() override;
 
  private:
   class SoftwareOutputSurface;
@@ -151,11 +135,9 @@ class SynchronousLayerTreeFrameSink
   void DeliverMessages();
   bool CalledOnValidThread() const;
 
-
-  const int routing_id_;
   const uint32_t layer_tree_frame_sink_id_;
-  SynchronousCompositorRegistry* const registry_;         // Not owned.
-  IPC::Sender* const sender_;                             // Not owned.
+  SynchronousCompositorRegistry* const registry_;  // Not owned.
+  IPC::Sender* const sender_;                      // Not owned.
 
   // Not owned.
   SynchronousLayerTreeFrameSinkClient* sync_client_ = nullptr;
@@ -165,7 +147,7 @@ class SynchronousLayerTreeFrameSink
   // process so there is no reason for it to use a SharedBitmapManager.
   viz::ServerSharedBitmapManager shared_bitmap_manager_;
 
-  // Only valid (non-NULL) during a DemandDrawSw() call.
+  // Only valid (non-null) during a DemandDrawSw() call.
   SkCanvas* current_sw_canvas_ = nullptr;
 
   cc::ManagedMemoryPolicy memory_policy_;
@@ -228,9 +210,9 @@ class SynchronousLayerTreeFrameSink
   bool begin_frames_paused_ = false;
   bool needs_begin_frames_ = false;
 
-  DISALLOW_COPY_AND_ASSIGN(SynchronousLayerTreeFrameSink);
+  DISALLOW_COPY_AND_ASSIGN(SynchronousLayerTreeFrameSinkImpl);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_RENDERER_ANDROID_SYNCHRONOUS_LAYER_TREE_FRAME_SINK_H_
+#endif  // CONTENT_RENDERER_ANDROID_SYNCHRONOUS_LAYER_TREE_FRAME_SINK_IMPL_H_