Hook up BeginFrameSource to SurfaceFactoryClient via SurfaceManager

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 <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.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 cc {
+class BeginFrameSource;
 class CompositorFrame;
 class Surface;
+class SurfaceFactoryClient;
 
 class CC_SURFACES_EXPORT SurfaceManager {
  public:
   SurfaceManager();
   ~SurfaceManager();
 
   void RegisterSurface(Surface* surface);
   void DeregisterSurface(SurfaceId surface_id);
 
   // Destroy the Surface once a set of sequence numbers has been satisfied.
@@ skipping 15 matching lines @@
   // id namespace.
   void DidSatisfySequences(uint32_t id_namespace,
                            std::vector<uint32_t>* sequence);
 
   void RegisterSurfaceIdNamespace(uint32_t id_namespace);
 
   // Invalidate a namespace that might still have associated sequences,
   // possibly because a renderer process has crashed.
   void InvalidateSurfaceIdNamespace(uint32_t id_namespace);
 
+  // SurfaceFactoryClient and namespace hierarchy may be registered in
+  // either order. (The relationship to between ui::Compositor /
+  // DelegatedFrameHost is known before ui::Compositor has a surface/client).
+  // However, DelegatedFrameHost can register itself as a client before
+  // its relationship with the ui::Compositor is known.)
+  //
+  // SurfaceFactoryClient registration for a namespace should outlive
+  // the BeginFrameSource registration.
+  //
+  // Associates a SurfaceFactoryClient with the surface id namespace it uses.
+  // SurfaceFactoryClient and surface namespaces/allocators have a 1:1 mapping.
+  // A nullptr client implies unregistering the client from the namespace.
+  // 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 id_namespace,

[brianderson, 2016/02/18 23:01:07]

Is it possible to fold this into RegisterSurfaceIdNamespace? Or will the
SurfaceFactoryClient not always be known by that point?

[enne (OOO), 2016/02/19 21:26:57]

Sadly, no.  SurfaceIdNamespace is about the allocator, which does not have the
same lifetime as the SurfaceFactoryClient.  I thought about refactoring this so
that surface factories owned their allocators and this could be combined.  To
that end, I talked about this with jbauman some, who said that there were goals
of moving the allocator off even farther away than it is now, so I think it's
important to keep them decoupled to enable that future refactoring.

+                                    SurfaceFactoryClient* client);
+
+  void RegisterBeginFrameSource(BeginFrameSource* source,
+                                uint32_t id_namespace);
+  void UnregisterBeginFrameSource(BeginFrameSource* source);
+
+  // TODO(enne): Call this in the right spots.
+  // Children should always register/unregister with their parents.
+  // Unregistration of child namespaces should happen before
+  // unregistering surface factory clients.
+  void RegisterSurfaceNamespaceHierarchy(uint32_t parent_namespace,
+                                         uint32_t child_namespace);
+  void UnregisterSurfaceNamespaceHierarchy(uint32_t parent_namespace,
+                                           uint32_t child_namespace);
+
  private:
+  void RecursivelyAttachBeginFrameSource(uint32_t id_namespace,
+                                         BeginFrameSource* source);
+  void RecursivelyDetachBeginFrameSource(uint32_t id_namespace,
+                                         BeginFrameSource* source);
+
   void GarbageCollectSurfaces();
 
   using SurfaceMap = std::unordered_map<SurfaceId, Surface*, SurfaceIdHash>;
   SurfaceMap surface_map_;
   base::ObserverList<SurfaceDamageObserver> 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<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<uint32_t> valid_surface_id_namespaces_;
 
+  // Begin frame source routing. Both BeginFrameSource and SurfaceFactoryClient
+  // pointers guaranteed alive by callers until unregistered.
+  struct ClientSourceMapping {
+    ClientSourceMapping();
+    ~ClientSourceMapping();
+    bool is_empty() const { return !client && !children.size(); }
+    // The client that's responsible for creating this namespace.  Never null.
+    SurfaceFactoryClient* client;
+    // 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::unordered_map<uint32_t, ClientSourceMapping> 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_;
+
   DISALLOW_COPY_AND_ASSIGN(SurfaceManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_SURFACES_SURFACE_MANAGER_H_