WIP: Propagate SurfaceID up window tree hierarchy

cc/surfaces/surface_manager.h

Index: cc/surfaces/surface_manager.h
diff --git a/cc/surfaces/surface_manager.h b/cc/surfaces/surface_manager.h
index 6261fb363c3953701547d6bde52267c439c9800c..ac4ee28da3acc6b21b7357fc4969e312e8e0a52d 100644
--- a/cc/surfaces/surface_manager.h
+++ b/cc/surfaces/surface_manager.h
@@ -16,11 +16,16 @@
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
+#include "cc/surfaces/frame_sink_id.h"
 #include "cc/surfaces/surface_damage_observer.h"
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "cc/surfaces/surfaces_export.h"
 
+namespace gfx {
+class Size;
+}  // namespace gfx
+
 namespace cc {
 class BeginFrameSource;
 class CompositorFrame;
@@ -29,7 +34,15 @@ class SurfaceFactoryClient;
 
 class CC_SURFACES_EXPORT SurfaceManager {
  public:
-  SurfaceManager();
+  class Delegate {
+   public:
+    virtual ~Delegate() = default;
+    virtual void OnSurfaceCreated(const gfx::Size& size,
+                                  float device_scale_factor,
+                                  const SurfaceId& surface_id) = 0;
+  };
+
+  explicit SurfaceManager(Delegate* delegate);
   ~SurfaceManager();
 
   void RegisterSurface(Surface* surface);
@@ -50,15 +63,20 @@ class CC_SURFACES_EXPORT SurfaceManager {
 
   bool SurfaceModified(const SurfaceId& surface_id);
 
+  void DidCreateNewSurface(const gfx::Size& size,
+                           float device_scale_factor,
+                           const SurfaceId& surface_id);
+
   // A frame for a surface satisfies a set of sequence numbers in a particular
   // id namespace.
-  void DidSatisfySequences(uint32_t client_id, std::vector<uint32_t>* sequence);
+  void DidSatisfySequences(const FrameSinkId& frame_sink_id,
+                           std::vector<uint32_t>* sequence);
 
-  void RegisterSurfaceClientId(uint32_t client_id);
+  void RegisterFrameSinkId(const FrameSinkId& frame_sink_id);
 
-  // Invalidate a namespace that might still have associated sequences,
+  // Invalidate a frame_sink_id that might still have associated sequences,
   // possibly because a renderer process has crashed.
-  void InvalidateSurfaceClientId(uint32_t client_id);
+  void InvalidateFrameSinkId(const FrameSinkId& frame_sink_id);
 
   // SurfaceFactoryClient, hierarchy, and BeginFrameSource can be registered
   // and unregistered in any order with respect to each other.
@@ -68,40 +86,46 @@ class CC_SURFACES_EXPORT SurfaceManager {
   // However, DelegatedFrameHost can register itself as a client before its
   // relationship with the ui::Compositor is known.
 
-  // Associates a SurfaceFactoryClient with the surface id namespace it uses.
+  // Associates a SurfaceFactoryClient with the surface id frame_sink_id it
+  // uses.
   // SurfaceFactoryClient and surface namespaces/allocators have a 1:1 mapping.
   // Caller guarantees the client is alive between register/unregister.
   // Reregistering the same namespace when a previous client is active is not
   // valid.
-  void RegisterSurfaceFactoryClient(uint32_t client_id,
+  void RegisterSurfaceFactoryClient(const FrameSinkId& frame_sink_id,
                                     SurfaceFactoryClient* client);
-  void UnregisterSurfaceFactoryClient(uint32_t client_id);
+  void UnregisterSurfaceFactoryClient(const FrameSinkId& frame_sink_id);
 
   // Associates a |source| with a particular namespace.  That namespace and
   // any children of that namespace with valid clients can potentially use
   // that |source|.
-  void RegisterBeginFrameSource(BeginFrameSource* source, uint32_t client_id);
+  void RegisterBeginFrameSource(BeginFrameSource* source,
+                                const FrameSinkId& frame_sink_id);
   void UnregisterBeginFrameSource(BeginFrameSource* source);
 
   // Register a relationship between two namespaces.  This relationship means
   // that surfaces from the child namespace will be displayed in the parent.
   // Children are allowed to use any begin frame source that their parent can
   // use.
-  void RegisterSurfaceNamespaceHierarchy(uint32_t parent_namespace,
-                                         uint32_t child_namespace);
-  void UnregisterSurfaceNamespaceHierarchy(uint32_t parent_namespace,
-                                           uint32_t child_namespace);
+  void RegisterFrameSinkHierarchy(const FrameSinkId& parent_frame_sink_id,
+                                  const FrameSinkId& child_frame_sink_id);
+  void UnregisterFrameSinkHierarchy(const FrameSinkId& parent_frame_sink_id,
+                                    const FrameSinkId& child_frame_sink_id);
 
  private:
-  void RecursivelyAttachBeginFrameSource(uint32_t client_id,
+  void RecursivelyAttachBeginFrameSource(const FrameSinkId& frame_sink_id,
                                          BeginFrameSource* source);
-  void RecursivelyDetachBeginFrameSource(uint32_t client_id,
+  void RecursivelyDetachBeginFrameSource(const FrameSinkId& frame_sink_id,
                                          BeginFrameSource* source);
-  // Returns true if |child namespace| is or has |search_namespace| as a child.
-  bool ChildContains(uint32_t child_namespace, uint32_t search_namespace) const;
+  // 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;
 
   void GarbageCollectSurfaces();
 
+  Delegate* const delegate_;
+
   using SurfaceMap = std::unordered_map<SurfaceId, Surface*, SurfaceIdHash>;
   SurfaceMap surface_map_;
   base::ObserverList<SurfaceDamageObserver> observer_list_;
@@ -119,7 +143,7 @@ class CC_SURFACES_EXPORT SurfaceManager {
   // 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<uint32_t> valid_surface_client_ids_;
+  std::unordered_set<FrameSinkId, FrameSinkIdHash> valid_frame_sink_ids_;
 
   // Begin frame source routing. Both BeginFrameSource and SurfaceFactoryClient
   // pointers guaranteed alive by callers until unregistered.
@@ -133,13 +157,14 @@ class CC_SURFACES_EXPORT SurfaceManager {
     // The currently assigned begin frame source for this client.
     BeginFrameSource* source;
     // This represents a dag of parent -> children mapping.
-    std::vector<uint32_t> children;
+    std::vector<FrameSinkId> children;
   };
-  std::unordered_map<uint32_t, ClientSourceMapping> namespace_client_map_;
+  std::unordered_map<FrameSinkId, ClientSourceMapping, FrameSinkIdHash>
+      namespace_client_map_;
   // 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*, uint32_t> registered_sources_;
+  std::unordered_map<BeginFrameSource*, FrameSinkId> registered_sources_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceManager);
 };