Add debug method to print surface references.

cc/surfaces/surface_manager.cc

 // 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.
 
 #include "cc/surfaces/surface_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 #include <utility>
 
 #include "base/logging.h"
 #include "cc/surfaces/direct_surface_reference_factory.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_id_allocator.h"
 
+#if DCHECK_IS_ON()
+#include <sstream>
+#endif
+
 namespace cc {
 
 SurfaceManager::FrameSinkSourceMapping::FrameSinkSourceMapping()
     : client(nullptr), source(nullptr) {}
 
 SurfaceManager::FrameSinkSourceMapping::FrameSinkSourceMapping(
     const FrameSinkSourceMapping& other) = default;
 
 SurfaceManager::FrameSinkSourceMapping::~FrameSinkSourceMapping() {
   DCHECK(is_empty()) << "client: " << client
@@ skipping 18 matching lines @@
     DeregisterSurface((*it)->surface_id());
   }
   surfaces_to_destroy_.clear();
 
   // All hierarchies, sources, and surface factory clients should be
   // unregistered prior to SurfaceManager destruction.
   DCHECK_EQ(frame_sink_source_map_.size(), 0u);
   DCHECK_EQ(registered_sources_.size(), 0u);
 }
 
+#if DCHECK_IS_ON()
+std::string SurfaceManager::SurfaceReferencesToString() {
+  std::stringstream str;
+  SurfaceReferencesToStringImpl(root_surface_id_, "", &str);
+  return str.str();
+}
+#endif
+
 void SurfaceManager::RegisterSurface(Surface* surface) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface);
   DCHECK(!surface_map_.count(surface->surface_id()));
   surface_map_[surface->surface_id()] = surface;
 }
 
 void SurfaceManager::DeregisterSurface(const SurfaceId& surface_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SurfaceMap::iterator it = surface_map_.find(surface_id);
@@ skipping 96 matching lines @@
     return 0;
   return iter->second.size();
 }
 
 void SurfaceManager::GarbageCollectSurfacesFromRoot() {
   DCHECK_EQ(lifetime_type_, LifetimeType::REFERENCES);
 
   if (surfaces_to_destroy_.empty())
     return;
 
-  std::unordered_set<SurfaceId, SurfaceIdHash> reachable_surfaces;
+  SurfaceIdSet reachable_surfaces;
 
   // Walk down from the root and mark each SurfaceId we encounter as reachable.
   std::queue<SurfaceId> surface_queue;
   surface_queue.push(root_surface_id_);
   while (!surface_queue.empty()) {
     const SurfaceId& surface_id = surface_queue.front();
     auto iter = parent_to_child_refs_.find(surface_id);
     if (iter != parent_to_child_refs_.end()) {
       for (const SurfaceId& child_id : iter->second) {
         // Check for cycles when inserting into |reachable_surfaces|.
@@ skipping 317 matching lines @@
     observer.OnSurfaceDamaged(surface_id, &changed);
   return changed;
 }
 
 void SurfaceManager::SurfaceCreated(const SurfaceInfo& surface_info) {
   CHECK(thread_checker_.CalledOnValidThread());
   for (auto& observer : observer_list_)
     observer.OnSurfaceCreated(surface_info);
 }
 
+#if DCHECK_IS_ON()
+void SurfaceManager::SurfaceReferencesToStringImpl(const SurfaceId& surface_id,
+                                                   std::string indent,
+                                                   std::stringstream* str) {
+  *str << indent;
+
+  // Print the current line for |surface_id|.
+  Surface* surface = GetSurfaceForId(surface_id);
+  if (surface) {
+    *str << surface->surface_id().ToString();
+    *str << (surface->destroyed() ? " destroyed " : " live ");
+
+    if (surface->HasFrame()) {
+      // This provides the surface size from the root render pass.
+      const CompositorFrame& frame = surface->GetEligibleFrame();
+      *str << frame.render_pass_list.back()->output_rect.size().ToString();
+    }
+  } else {
+    *str << surface_id;
+  }
+  *str << "\n";
+
+  // If the current surface has references to children, sort children and print
+  // references for each child.
+  auto iter = parent_to_child_refs_.find(surface_id);
+  if (iter != parent_to_child_refs_.end()) {
+    std::vector<SurfaceId> children(iter->second.begin(), iter->second.end());
+    std::sort(children.begin(), children.end());
+
+    for (const SurfaceId& child_id : children)
+      SurfaceReferencesToStringImpl(child_id, indent + "  ", str);
+  }
+}
+#endif  // DCHECK_IS_ON()
+
 }  // namespace cc