Move frame_sink_id management to framesink_manager.cc/h from

cc/surfaces/direct_compositor_frame_sink.cc

 // Copyright 2014 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 "cc/surfaces/direct_compositor_frame_sink.h"
 
 #include "base/bind.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_sink_client.h"
 #include "cc/surfaces/display.h"
 #include "cc/surfaces/frame_sink_id.h"
+#include "cc/surfaces/framesink_manager.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 
 namespace cc {
 
 DirectCompositorFrameSink::DirectCompositorFrameSink(
     const FrameSinkId& frame_sink_id,
     SurfaceManager* surface_manager,
+    FrameSinkManager* framesink_manager,
     Display* display,
     scoped_refptr<ContextProvider> context_provider,
     scoped_refptr<ContextProvider> worker_context_provider,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     SharedBitmapManager* shared_bitmap_manager)
     : CompositorFrameSink(std::move(context_provider),
                           std::move(worker_context_provider),
                           gpu_memory_buffer_manager,
                           shared_bitmap_manager),
       frame_sink_id_(frame_sink_id),
       surface_manager_(surface_manager),
+      framesink_manager_(framesink_manager),
       display_(display),
       factory_(frame_sink_id, surface_manager, this) {
   DCHECK(thread_checker_.CalledOnValidThread());
   capabilities_.can_force_reclaim_resources = true;
   // Display and DirectCompositorFrameSink share a GL context, so sync
   // points aren't needed when passing resources between them.
   capabilities_.delegated_sync_points_required = false;
   factory_.set_needs_sync_points(false);
 }
 
 DirectCompositorFrameSink::DirectCompositorFrameSink(
     const FrameSinkId& frame_sink_id,
     SurfaceManager* surface_manager,
+    FrameSinkManager* framesink_manager,
     Display* display,
     scoped_refptr<VulkanContextProvider> vulkan_context_provider)
     : CompositorFrameSink(std::move(vulkan_context_provider)),
       frame_sink_id_(frame_sink_id),
       surface_manager_(surface_manager),
+      framesink_manager_(framesink_manager),
       display_(display),
       factory_(frame_sink_id_, surface_manager, this) {
   DCHECK(thread_checker_.CalledOnValidThread());
   capabilities_.can_force_reclaim_resources = true;
 }
 
 DirectCompositorFrameSink::~DirectCompositorFrameSink() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool DirectCompositorFrameSink::BindToClient(
     CompositorFrameSinkClient* client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!CompositorFrameSink::BindToClient(client))
     return false;
 
-  surface_manager_->RegisterSurfaceFactoryClient(frame_sink_id_, this);
+  framesink_manager_->RegisterSurfaceFactoryClient(frame_sink_id_, this);
 
   // We want the Display's output surface to hear about lost context, and since
   // this shares a context with it, we should not be listening for lost context
   // callbacks on the context here.
   if (auto* cp = context_provider())
     cp->SetLostContextCallback(base::Closure());
 
   // Avoid initializing GL context here, as this should be sharing the
   // Display's context.
-  display_->Initialize(this, surface_manager_);
+  display_->Initialize(this, surface_manager_, framesink_manager_);

[Fady Samuel, 2017/02/12 19:04:07]

Does Display do anything useful with SurfaceManager?

[k.devara, 2017/02/13 06:47:34]

surface_manager itself is used to get surface_id for aggregator, root_surface
and to pass itself to surface_aggregator. 

But I needed o pass framesink_manager to display->Initialize()bcz of 
RegisterBeginFrameSource(frame_sink_id,begin_frame_source), a function that I
moved to framesink_manager.cc from surface_manager.cc

If frame_sink_id & begin_frame_source can be moved out of Display, we can avoid
having framesink_manager altogether in display.cc, which seems to make sense. It
will be better to have the Display deal with surface_id than frame_sink_id. and
leave all frame_sink_id references in the corresponding
xyz_compositor_frame_sinks.

Any ideas on this? I will submit a separate CL on this (making Display, free
frame_sink_id & begin_frame_source) 

   return true;
 }
 
 void DirectCompositorFrameSink::DetachFromClient() {
   // Unregister the SurfaceFactoryClient here instead of the dtor so that only
   // one client is alive for this namespace at any given time.
-  surface_manager_->UnregisterSurfaceFactoryClient(frame_sink_id_);
+  framesink_manager_->UnregisterSurfaceFactoryClient(frame_sink_id_);
   factory_.EvictSurface();
 
   CompositorFrameSink::DetachFromClient();
 }
 
 void DirectCompositorFrameSink::SubmitCompositorFrame(CompositorFrame frame) {
   gfx::Size frame_size = frame.render_pass_list.back()->output_rect.size();
   if (frame_size.IsEmpty() || frame_size != last_swap_frame_size_) {
     delegated_local_surface_id_ = surface_id_allocator_.GenerateId();
     last_swap_frame_size_ = frame_size;
@@ skipping 39 matching lines @@
   // This notification is not relevant to our client outside of tests. We
   // unblock the client from DidDrawCallback() when the surface is going to
   // be drawn.
 }
 
 void DirectCompositorFrameSink::DidDrawCallback() {
   client_->DidReceiveCompositorFrameAck();
 }
 
 }  // namespace cc