Replace SurfaceFactory in SynchronousCompositorFrameSink with CompositorFrameSinkSupport

content/renderer/android/synchronous_compositor_frame_sink.cc

 // Copyright 2013 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 "content/renderer/android/synchronous_compositor_frame_sink.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_sink_client.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_frame.h"
 #include "cc/output/renderer_settings.h"
 #include "cc/output/software_output_device.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/surface_draw_quad.h"
+#include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/display.h"
-#include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "content/common/android/sync_compositor_messages.h"
 #include "content/renderer/android/synchronous_compositor_filter.h"
 #include "content/renderer/android/synchronous_compositor_registry.h"
 #include "content/renderer/gpu/frame_swap_message_queue.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
@@ skipping 79 matching lines @@
                               gpu_memory_buffer_manager,
                               nullptr),
       routing_id_(routing_id),
       compositor_frame_sink_id_(compositor_frame_sink_id),
       registry_(registry),
       sender_(RenderThreadImpl::current()->sync_compositor_message_filter()),
       memory_policy_(0u),
       frame_swap_message_queue_(frame_swap_message_queue),
       surface_manager_(new cc::SurfaceManager),
       surface_id_allocator_(new cc::SurfaceIdAllocator()),
-      root_factory_(new cc::SurfaceFactory(kRootFrameSinkId,
-                                           surface_manager_.get(),
-                                           this)),
-      child_factory_(new cc::SurfaceFactory(kChildFrameSinkId,
-                                            surface_manager_.get(),
-                                            this)),
       begin_frame_source_(std::move(begin_frame_source)) {
   DCHECK(registry_);
   DCHECK(sender_);
   DCHECK(begin_frame_source_);
   thread_checker_.DetachFromThread();
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
 
 SynchronousCompositorFrameSink::~SynchronousCompositorFrameSink() = default;
@@ skipping 24 matching lines @@
     return false;
 
   DCHECK(begin_frame_source_);
   client_->SetBeginFrameSource(begin_frame_source_.get());
   client_->SetMemoryPolicy(memory_policy_);
   client_->SetTreeActivationCallback(
       base::Bind(&SynchronousCompositorFrameSink::DidActivatePendingTree,
                  base::Unretained(this)));
   registry_->RegisterCompositorFrameSink(routing_id_, this);
 
-  surface_manager_->RegisterFrameSinkId(kRootFrameSinkId);
-  surface_manager_->RegisterFrameSinkId(kChildFrameSinkId);
-  surface_manager_->RegisterSurfaceFactoryClient(kRootFrameSinkId, this);
-  surface_manager_->RegisterSurfaceFactoryClient(kChildFrameSinkId, this);
+  root_support_.reset(new cc::CompositorFrameSinkSupport(
+      this, surface_manager_.get(), kRootFrameSinkId,
+      true /* submits_to_display_compositor */));
+  child_support_.reset(new cc::CompositorFrameSinkSupport(
+      this, surface_manager_.get(), kChildFrameSinkId,
+      true /* submits_to_display_compositor */));

[Fady Samuel, 2017/02/13 21:24:14]

Ahh this doesn't hang off the root, so this is false, actually.

[Saman Sami, 2017/02/13 21:29:35]

Done.

 
   cc::RendererSettings software_renderer_settings;
 
   auto output_surface = base::MakeUnique<SoftwareOutputSurface>(
       base::MakeUnique<SoftwareDevice>(&current_sw_canvas_));
   software_output_surface_ = output_surface.get();
 
   // The shared_bitmap_manager and gpu_memory_buffer_manager here are null as
   // this Display is only used for resourcesless software draws, where no
   // resources are included in the frame swapped from the compositor. So there
   // is no need for these.
   display_.reset(new cc::Display(
       nullptr /* shared_bitmap_manager */,
       nullptr /* gpu_memory_buffer_manager */, software_renderer_settings,
       kRootFrameSinkId, nullptr /* begin_frame_source */,
       std::move(output_surface), nullptr /* scheduler */,
       nullptr /* texture_mailbox_deleter */));
   display_->Initialize(&display_client_, surface_manager_.get());
   display_->SetVisible(true);
   return true;
 }
 
 void SynchronousCompositorFrameSink::DetachFromClient() {
   DCHECK(CalledOnValidThread());
   client_->SetBeginFrameSource(nullptr);
   // Destroy the begin frame source on the same thread it was bound on.
   begin_frame_source_ = nullptr;
   registry_->UnregisterCompositorFrameSink(routing_id_, this);
   client_->SetTreeActivationCallback(base::Closure());
-  root_factory_->EvictSurface();
-  child_factory_->EvictSurface();
-  surface_manager_->UnregisterSurfaceFactoryClient(kRootFrameSinkId);
-  surface_manager_->UnregisterSurfaceFactoryClient(kChildFrameSinkId);
-  surface_manager_->InvalidateFrameSinkId(kRootFrameSinkId);
-  surface_manager_->InvalidateFrameSinkId(kChildFrameSinkId);
+  root_support_.reset();
+  child_support_.reset();
   software_output_surface_ = nullptr;
   display_ = nullptr;
-  child_factory_ = nullptr;
-  root_factory_ = nullptr;
   surface_id_allocator_ = nullptr;
   surface_manager_ = nullptr;
   cc::CompositorFrameSink::DetachFromClient();
   CancelFallbackTick();
 }
 
-static void NoOpDrawCallback() {}
-
 void SynchronousCompositorFrameSink::SubmitCompositorFrame(
     cc::CompositorFrame frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_client_);
 
   if (fallback_tick_running_) {
     DCHECK(frame.resource_list.empty());
     cc::ReturnedResourceArray return_resources;
-    ReturnResources(return_resources);
+    ReclaimResources(return_resources);
     did_submit_frame_ = true;
     return;
   }
 
   cc::CompositorFrame submit_frame;
 
   if (in_software_draw_) {
     // The frame we send to the client is actually just the metadata. Preserve
     // the |frame| for the software path below.
     submit_frame.metadata = frame.metadata.Clone();
@@ skipping 43 matching lines @@
     auto* surface_quad =
         embed_render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
     shared_quad_state->SetAll(
         child_transform, child_size, gfx::Rect(child_size),
         gfx::Rect() /* clip_rect */, false /* is_clipped */, 1.f /* opacity */,
         SkBlendMode::kSrcOver, 0 /* sorting_context_id */);
     surface_quad->SetNew(
         shared_quad_state, gfx::Rect(child_size), gfx::Rect(child_size),
         cc::SurfaceId(kChildFrameSinkId, child_local_surface_id_));
 
-    child_factory_->SubmitCompositorFrame(child_local_surface_id_,
-                                          std::move(frame),
-                                          base::Bind(&NoOpDrawCallback));
-    root_factory_->SubmitCompositorFrame(root_local_surface_id_,
-                                         std::move(embed_frame),
-                                         base::Bind(&NoOpDrawCallback));
+    child_support_->SubmitCompositorFrame(child_local_surface_id_,
+                                          std::move(frame));
+    root_support_->SubmitCompositorFrame(root_local_surface_id_,
+                                         std::move(embed_frame));
     display_->DrawAndSwap();
   } else {
     // For hardware draws we send the whole frame to the client so it can draw
     // the content in it.
     submit_frame = std::move(frame);
   }
 
   sync_client_->SubmitCompositorFrame(compositor_frame_sink_id_,
                                       std::move(submit_frame));
   DeliverMessages();
@@ skipping 142 matching lines @@
 
 bool SynchronousCompositorFrameSink::Send(IPC::Message* message) {
   DCHECK(CalledOnValidThread());
   return sender_->Send(message);
 }
 
 bool SynchronousCompositorFrameSink::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
-void SynchronousCompositorFrameSink::ReturnResources(
+void SynchronousCompositorFrameSink::DidReceiveCompositorFrameAck() {}
+
+void SynchronousCompositorFrameSink::OnBeginFrame(
+    const cc::BeginFrameArgs& args) {}
+
+void SynchronousCompositorFrameSink::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
   DCHECK(resources.empty());
   client_->ReclaimResources(resources);
 }
 
-void SynchronousCompositorFrameSink::SetBeginFrameSource(
-    cc::BeginFrameSource* begin_frame_source) {
-  // Software output is synchronous and doesn't use a BeginFrameSource.
-  NOTREACHED();
-}
+void SynchronousCompositorFrameSink::WillDrawSurface() {}
 
 }  // namespace content