[WIP] cc: Plumb SurfaceId from clients

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/gtest_prod_util.h"
 #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;
 
+namespace test {
+class SurfaceDisplayOutputSurfaceTest;
+}
+
 class CC_SURFACES_EXPORT SurfaceManager {
  public:
   SurfaceManager();
   ~SurfaceManager();
 
   void RegisterSurface(Surface* surface);
   void DeregisterSurface(const SurfaceId& surface_id);
 
   // Destroy the Surface once a set of sequence numbers has been satisfied.
   void Destroy(std::unique_ptr<Surface> surface);
 
   Surface* GetSurfaceForId(const SurfaceId& surface_id);
 
   void AddObserver(SurfaceDamageObserver* obs) {
     observer_list_.AddObserver(obs);
   }
 
   void RemoveObserver(SurfaceDamageObserver* obs) {
     observer_list_.RemoveObserver(obs);
   }
 
   bool SurfaceModified(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 RegisterSurfaceClientId(uint32_t client_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 UnregisterBeginFrameSource(BeginFrameSource* source);
 
-  // Invalidate a namespace that might still have associated sequences,
-  // possibly because a renderer process has crashed.
-  void InvalidateSurfaceClientId(uint32_t client_id);
+ private:
+  FRIEND_TEST_ALL_PREFIXES(SurfaceManagerTest, SingleClients);
+  FRIEND_TEST_ALL_PREFIXES(SurfaceManagerTest, MultipleDisplays);
+  friend class SurfaceManagerOrderingTest;
+  friend class SurfaceFactory;
+  friend class test::SurfaceDisplayOutputSurfaceTest;
+  friend class FakeSurfaceFactoryClient;
+
+  // Register a relationship between two clients.  This relationship means
+  // that surfaces from the child client 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);
 
   // SurfaceFactoryClient, hierarchy, and BeginFrameSource can be registered
   // and unregistered in any order with respect to each other.
   //
   // This happens in practice, e.g. 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.
 
   // Associates a SurfaceFactoryClient with the surface id namespace 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,
-                                    SurfaceFactoryClient* client);
-  void UnregisterSurfaceFactoryClient(uint32_t client_id);
+  void RegisterClient(uint32_t client_id, SurfaceFactoryClient* client);
+  void UnregisterClient(uint32_t client_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 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);
-
- private:
   void RecursivelyAttachBeginFrameSource(uint32_t client_id,
                                          BeginFrameSource* source);
   void RecursivelyDetachBeginFrameSource(uint32_t client_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;
 
   void GarbageCollectSurfaces();
 
   using SurfaceMap = std::unordered_map<SurfaceId, Surface*, SurfaceIdHash>;
@@ skipping 34 matching lines @@
   // 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_