Add cc::Surface ref counting.

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>
@@ skipping 12 matching lines @@
 #include "cc/surfaces/surfaces_export.h"
 
 namespace cc {
 class BeginFrameSource;
 class CompositorFrame;
 class Surface;
 class SurfaceFactoryClient;
 
 class CC_SURFACES_EXPORT SurfaceManager {
  public:
+  // Root SurfaceId that references display root surfaces. There is no Surface
+  // with this id, it's for bookkeeping purposes only.
+  static const SurfaceId kRootSurfaceId;
+
   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);
@@ skipping 16 matching lines @@
   // id namespace.
   void DidSatisfySequences(const FrameSinkId& frame_sink_id,
                            std::vector<uint32_t>* sequence);
 
   void RegisterFrameSinkId(const FrameSinkId& frame_sink_id);
 
   // Invalidate a frame_sink_id that might still have associated sequences,
   // possibly because a renderer process has crashed.
   void InvalidateFrameSinkId(const FrameSinkId& frame_sink_id);
 
+  // Adds a reference from a parent surface to a child surface. Any surface
+  // embedding a child surface should have a reference added so that the child
+  // surface is not garbage collected until after the parent surface.
+  void AddSurfaceReference(const SurfaceId& parent_id,
+                           const SurfaceId& child_id);
+
+  // Removes a reference from a parent surface to a child surface. If
+  // |should_run_gc| is true and the child surface drops to zero references then
+  // GC will run.
+  void RemoveSurfaceReference(const SurfaceId& parent_id,
+                              const SurfaceId& child_id,
+                              bool should_run_gc = true);
+
+  // Returns the number of surfaces that have references to |surface_id|. When
+  // the count is zero nothing is referencing the surface and it may be garbage
+  // collected.
+  size_t GetSurfaceReferenceCount(const SurfaceId& surface_id) const;
+
+  // Returns the number of surfaces that |surface_id| has references to.
+  size_t GetSurfaceRefereeCount(const SurfaceId& surface_id) const;

[Fady Samuel, 2016/11/02 03:10:36]

I'm not a fan of the name, maybe GetReferencedSurfacesCount? This is just a
suggestion. Feel free to ignore.

[kylechar, 2016/11/02 13:58:59]

Done.

+
   // 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 frame_sink_id it
   // uses.
@@ skipping 61 matching lines @@
     bool is_empty() const { return !client && children.empty(); }
     // 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<FrameSinkId> children;
   };
   std::unordered_map<FrameSinkId, FrameSinkSourceMapping, FrameSinkIdHash>
       frame_sink_source_map_;
+
+  using SurfaceIdSet = std::unordered_set<SurfaceId, SurfaceIdHash>;
+  // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_SURFACES_SURFACE_MANAGER_H_