Add debug method to print surface references.

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/compiler_specific.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/surface_id.h"
 #include "cc/surfaces/surface_observer.h"
 #include "cc/surfaces/surface_reference_factory.h"
 #include "cc/surfaces/surface_reference_manager.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "cc/surfaces/surfaces_export.h"
 
+#if DCHECK_IS_ON()

[danakj, 2017/01/18 16:57:11]

should include base/logging.h for this macro

[kylechar, 2017/01/18 18:04:58]

Done.

+#include <iosfwd>
+#include <string>
+#endif
+
 namespace cc {
 class BeginFrameSource;
 class CompositorFrame;
 class Surface;
 class SurfaceFactoryClient;
 
 class CC_SURFACES_EXPORT SurfaceManager
     : public NON_EXPORTED_BASE(SurfaceReferenceManager) {
  public:
   enum class LifetimeType {
     REFERENCES,
     SEQUENCES,
   };
 
   explicit SurfaceManager(LifetimeType lifetime_type = LifetimeType::SEQUENCES);
   ~SurfaceManager() override;
 
+#if DCHECK_IS_ON()
+  // Returns a string representation of all reachable surface references.
+  std::string SurfaceReferencesToString();
+#endif
+
   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(SurfaceObserver* obs) { observer_list_.AddObserver(obs); }
 
@@ skipping 63 matching lines @@
   void RemoveSurfaceReference(const SurfaceId& parent_id,
                               const SurfaceId& child_id) override;
   size_t GetSurfaceReferenceCount(const SurfaceId& surface_id) const override;
   size_t GetReferencedSurfaceCount(const SurfaceId& surface_id) const override;
 
   scoped_refptr<SurfaceReferenceFactory> reference_factory() {
     return reference_factory_;
   }
 
  private:
+  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 not reachable from the root. Used
   // when |use_references_| is true.
   void GarbageCollectSurfacesFromRoot();
   void GarbageCollectSurfaces();
 
   // Removes reference from a parent surface to a child surface. Used to remove
   // references without triggered GC.
   void RemoveSurfaceReferenceImpl(const SurfaceId& parent_id,
                                   const SurfaceId& child_id);
 
+#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_;
 
   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.
@@ skipping 19 matching lines @@
     // 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_;
 
@@ skipping 11 matching lines @@
   scoped_refptr<SurfaceReferenceFactory> reference_factory_;
 
   base::WeakPtrFactory<SurfaceManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_SURFACES_SURFACE_MANAGER_H_