Move frame_sink_id management to framesink_manager.cc/h from

cc/surfaces/surface_manager.h

 // 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.
 
 #ifndef CC_SURFACES_SURFACE_MANAGER_H_
 #define CC_SURFACES_SURFACE_MANAGER_H_
 
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "cc/surfaces/frame_sink_id.h"
+#include "cc/surfaces/framesink_manager.h"
 #include "cc/surfaces/surface_dependency_tracker.h"
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_observer.h"
 #include "cc/surfaces/surface_reference.h"
 #include "cc/surfaces/surface_reference_factory.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "cc/surfaces/surfaces_export.h"
 
 #if DCHECK_IS_ON()
 #include <iosfwd>
@@ skipping 136 matching lines @@
   bool using_surface_references() const {
     return lifetime_type_ == LifetimeType::REFERENCES;
   }
 
  private:
   friend class test::CompositorFrameSinkSupportTest;
   friend class SurfaceManagerRefTest;
 
   using SurfaceIdSet = std::unordered_set<SurfaceId, SurfaceIdHash>;
 
-  void RecursivelyAttachBeginFrameSource(const FrameSinkId& frame_sink_id,
-                                         BeginFrameSource* source);
-  void RecursivelyDetachBeginFrameSource(const FrameSinkId& frame_sink_id,
-                                         BeginFrameSource* source);
-
-  // Returns true if |child namespace| is or has |search_frame_sink_id| as a
-  // child.
-  bool ChildContains(const FrameSinkId& child_frame_sink_id,
-                     const FrameSinkId& search_frame_sink_id) const;
-
   // Garbage collects all destroyed surfaces that aren't live.
   void GarbageCollectSurfaces();
 
   // Returns set of live surfaces for |lifetime_manager_| is REFERENCES.
   SurfaceIdSet GetLiveSurfacesForReferences();
 
   // Returns set of live surfaces for |lifetime_manager_| is SEQUENCES.
   SurfaceIdSet GetLiveSurfacesForSequences();
 
   // Adds a reference from |parent_id| to |child_id| without dealing with
@@ skipping 27 matching lines @@
 #if DCHECK_IS_ON()
   // Recursively prints surface references starting at |surface_id| to |str|.
   void SurfaceReferencesToStringImpl(const SurfaceId& surface_id,
                                      std::string indent,
                                      std::stringstream* str);
 #endif
 
   // Use reference or sequence based lifetime management.
   LifetimeType lifetime_type_;
 
+  FrameSinkManager framesink_manager_;
+
   using SurfaceMap = std::unordered_map<SurfaceId, Surface*, SurfaceIdHash>;
   SurfaceMap surface_map_;
   base::ObserverList<SurfaceObserver> observer_list_;
   base::ThreadChecker thread_checker_;
 
   // List of surfaces to be destroyed, along with what sequences they're still
   // waiting on.
   using SurfaceDestroyList = std::list<std::unique_ptr<Surface>>;
   SurfaceDestroyList surfaces_to_destroy_;
 
   // Set of SurfaceSequences that have been satisfied by a frame but not yet
   // waited on.
   std::unordered_set<SurfaceSequence, SurfaceSequenceHash> satisfied_sequences_;
 
-  // Set of valid surface ID namespaces. When a namespace is removed from
-  // this set, any remaining sequences with that namespace are considered
-  // satisfied.
-  std::unordered_set<FrameSinkId, FrameSinkIdHash> valid_frame_sink_ids_;
-
-  // Begin frame source routing. Both BeginFrameSource and SurfaceFactoryClient
-  // pointers guaranteed alive by callers until unregistered.
-  struct FrameSinkSourceMapping {
-    FrameSinkSourceMapping();
-    FrameSinkSourceMapping(const FrameSinkSourceMapping& other);
-    ~FrameSinkSourceMapping();
-    bool has_children() const { return !children.empty(); }
-    // The currently assigned begin frame source for this client.
-    BeginFrameSource* source;
-    // This represents a dag of parent -> children mapping.
-    std::vector<FrameSinkId> children;
-  };
-
-  std::unordered_map<FrameSinkId, SurfaceFactoryClient*, FrameSinkIdHash>
-      clients_;
-
-  std::unordered_map<FrameSinkId, FrameSinkSourceMapping, FrameSinkIdHash>
-      frame_sink_source_map_;
-
   // Tracks references from the child surface to parent surface. If there are
   // zero entries in the set for a SurfaceId then nothing is referencing the
   // surface and it can be garbage collected.
   std::unordered_map<SurfaceId, SurfaceIdSet, SurfaceIdHash>
       child_to_parent_refs_;
   // Tracks references from the parent surface to child surface. Is the inverse
   // of |child_to_parent_refs_|.
   std::unordered_map<SurfaceId, SurfaceIdSet, SurfaceIdHash>
       parent_to_child_refs_;
 
-  // Set of which sources are registered to which namespace.  Any child
-  // that is implicitly using this namespace must be reachable by the
-  // parent in the dag.
-  std::unordered_map<BeginFrameSource*, FrameSinkId> registered_sources_;
-
   // Root SurfaceId that references display root surfaces. There is no Surface
   // with this id, it's for bookkeeping purposes only.
   const SurfaceId root_surface_id_;
 
   // The DirectSurfaceReferenceFactory that uses this manager to create surface
   // references.
   scoped_refptr<SurfaceReferenceFactory> reference_factory_;
 
   // A map of surfaces that have temporary references to them. The key is the
   // SurfaceId and the value is the owner. The owner will initially be empty and
@@ skipping 16 matching lines @@
   std::unique_ptr<SurfaceDependencyTracker> dependency_tracker_;
 
   base::WeakPtrFactory<SurfaceManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_SURFACES_SURFACE_MANAGER_H_