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"
 
 namespace cc {
 
+namespace {
+
+std::string SurfaceToString(const Surface& surface) {

[danakj, 2017/01/17 23:21:57]

seems like this should use the stringstream?

[kylechar, 2017/01/18 15:06:18]

Sure. It's not that useful as a function on it's own if it doesn't return a
string though, so I moved it back into the SurfaceReferencesToStringImpl method.

+  std::string str = surface.surface_id().ToString();
+  str += surface.destroyed() ? " destroyed " : " live";
+
+  if (surface.HasFrame()) {
+    str += surface.GetEligibleFrame()
+               .render_pass_list[0]

[danakj, 2017/01/17 23:21:57]

dont u want the back? why the topmost one?

[kylechar, 2017/01/18 15:06:18]

I probably do want the back one if you're asking :) I had assumed the
render_pass_list[0] got drawn first, so it would be the biggest usually, but
that must not be right.

What exactly is the point of RenderPass anyways? Like, what does have multiple
RenderPass objects made up a depth ordered quads let you do rather than just
having more quads in a single RenderPass?

[danakj, 2017/01/18 16:50:40]

A renderpass is an indirect surface that we draw into then use as a source into
another renderpass. It lets us apply effects to all the things drawn into it as
a single unit that we could not to each of the elements individually. Some
examples are blurs and transparency. We also use them for masks, and also for
clipping when the clip isn't a right-angle rectangle in its target, since we can
draw at some other angle into a texture and pixels that fall of the edge are
implicitly clipped. 

Think if you have two rects that partially overlap and are each 50% opacity.
Then you can see teh bottom rect thru the top rect. Now consider if you want
them to have 50% opacity TOGETHER. You have to draw them both then apply 50% to
that, now you can see them them but you don't see teh bottom rect thru the top
one.

They are in the order we draw them, you're right. This isn't documented on
CompositorFrame, it probably should be. This can be found here
https://cs.chromium.org/chromium/src/cc/trees/layer_tree_host_impl.cc?rcl=148...
where we "AppendRenderPasses" which ends up doing push_back
(https://cs.chromium.org/chromium/src/cc/trees/layer_tree_host_impl.cc?rcl=148...)
in "dependency order" meaning A depends on B if B draws into A, so B comes first
ie exactly first one is drawn into first. The order is the same as found in the
RenderSurfaceLayerList, which is the output of
LayerTreeHostCommon::CalculateDrawProperties. This is all more subtle and not
described in comments than I thought it was going to be...

Anyhow, this makes the back one the root, or the one all the others draw into.
So its most representative of the size as it clips the rest, also usually the
largest modulo said clipping.

+               ->output_rect.size()
+               .ToString();
+  }
+
+  return str;
+}
+
+}  // namespace
+
 SurfaceManager::FrameSinkSourceMapping::FrameSinkSourceMapping()
     : client(nullptr), source(nullptr) {}
 
 SurfaceManager::FrameSinkSourceMapping::FrameSinkSourceMapping(
     const FrameSinkSourceMapping& other) = default;
 
 SurfaceManager::FrameSinkSourceMapping::~FrameSinkSourceMapping() {
   DCHECK(is_empty()) << "client: " << client
                      << ", children: " << children.size();
 }
@@ skipping 16 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 !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+
+std::string SurfaceManager::PrintSurfaceReferences() {
+  std::stringstream str;
+  // Starting a |root_surface_id_| will print all reachable surfaces.

[danakj, 2017/01/17 23:21:57]

starting at? seems mostly duplicating the header tho

[kylechar, 2017/01/18 15:06:18]

Removed.

+  PrintSurfaceReferencesImpl(root_surface_id_, "", &str);
+  return str.str();
+}
+
+#endif  // !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)

[danakj, 2017/01/17 23:21:57]

i dont think u need the // here when its only like 6 lines

[kylechar, 2017/01/18 15:06:18]

Done.

+
 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 !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+
+void SurfaceManager::PrintSurfaceReferencesImpl(const SurfaceId& surface_id,

[danakj, 2017/01/17 23:21:57]

You could do this with a lambda and then the stringstream stuff would be only in
the .cc file..

[kylechar, 2017/01/18 15:06:18]

It's possible but the lambda definition isn't the most readable, since you can't
use auto with a recursive lambda. What do you think?

std::function<void(const SurfaceId&, std::string, std::stringstream*)>
      SurfaceReferencesToStringImpl = [this, &SurfaceReferencesToStringImpl](
          const SurfaceId& surface_id, std::string indent,
          std::stringstream* str) {

[danakj, 2017/01/18 16:53:47]

Ah, std::function is banned. http://chromium-cpp.appspot.com/ You'd use a
Callback to do that, which you could. But then the lambda needs to not capture,
and take those as arguments instead.

+                                                std::string indent,
+                                                std::stringstream* str) {
+  Surface* surface = GetSurfaceForId(surface_id);
+
+  *str << indent;
+  *str << (surface ? SurfaceToString(*surface) : surface_id.ToString());
+  *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()) {
+    const SurfaceIdSet& children = iter->second;

[danakj, 2017/01/17 23:21:57]

Set is a misleading name, it sounds ordered already.. :/

[kylechar, 2017/01/18 15:06:18]

It's not really necessary, so removed the variable entirely. Although I can
change the typedef name if you want?

+    std::vector<SurfaceId> list(children.begin(), children.end());
+    std::sort(list.begin(), list.end());
+
+    for (const SurfaceId& child_id : list)
+      PrintSurfaceReferencesImpl(child_id, indent + "  ", str);
+  }
+}
+
+#endif  // !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+
 }  // namespace cc