Add/remove surface references via MojoCompositorFrameSink.

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 <utility>
@@ skipping 10 matching lines @@
 
 SurfaceManager::FrameSinkSourceMapping::FrameSinkSourceMapping(
     const FrameSinkSourceMapping& other) = default;
 
 SurfaceManager::FrameSinkSourceMapping::~FrameSinkSourceMapping() {
   DCHECK(is_empty()) << "client: " << client
                      << ", children: " << children.size();
 }
 
 SurfaceManager::SurfaceManager()
-    : kRootSurfaceId(FrameSinkId(0u, 0u),
-                     LocalFrameId(0u, base::UnguessableToken::Create())) {
+    : root_surface_id_(FrameSinkId(0u, 0u),
+                       LocalFrameId(1u, base::UnguessableToken::Create())) {
   thread_checker_.DetachFromThread();
 }
 
 SurfaceManager::~SurfaceManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (SurfaceDestroyList::iterator it = surfaces_to_destroy_.begin();
        it != surfaces_to_destroy_.end();
        ++it) {
     DeregisterSurface((*it)->surface_id());
   }
@@ skipping 41 matching lines @@
   bool inserted = valid_frame_sink_ids_.insert(frame_sink_id).second;
   DCHECK(inserted);
 }
 
 void SurfaceManager::InvalidateFrameSinkId(const FrameSinkId& frame_sink_id) {
   valid_frame_sink_ids_.erase(frame_sink_id);
   GarbageCollectSurfaces();
 }
 
 const SurfaceId& SurfaceManager::GetRootSurfaceId() const {
-  return kRootSurfaceId;
+  return root_surface_id_;
 }
 
 void SurfaceManager::AddSurfaceReference(const SurfaceId& parent_id,
                                          const SurfaceId& child_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Check some conditions that should never happen. We don't want to crash on
   // bad input from a compromised client so just return early.
   if (parent_id == child_id) {
     LOG(ERROR) << "Cannot add self reference for " << parent_id.ToString();
-    return;
+    NOTREACHED();
   }
-  if (parent_id != kRootSurfaceId && surface_map_.count(parent_id) == 0) {
+  if (parent_id != root_surface_id_ && surface_map_.count(parent_id) == 0) {
     LOG(ERROR) << "No surface in map for " << parent_id.ToString();
-    return;
+    NOTREACHED();
   }
   if (surface_map_.count(child_id) == 0) {
     LOG(ERROR) << "No surface in map for " << child_id.ToString();
-    return;
+    NOTREACHED();
   }
 
   parent_to_child_refs_[parent_id].insert(child_id);
   child_to_parent_refs_[child_id].insert(parent_id);
 }
 
 void SurfaceManager::RemoveSurfaceReference(const SurfaceId& parent_id,
                                             const SurfaceId& child_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Check if we have the reference that is requested to be removed. We don't
   // want to crash on bad input from a compromised client so just return early.
   if (parent_to_child_refs_.count(parent_id) == 0 ||
       parent_to_child_refs_[parent_id].count(child_id) == 0) {
     LOG(ERROR) << "No reference from " << parent_id.ToString() << " to "
                << child_id.ToString();
-    return;
+    NOTREACHED();
   }
 
   RemoveSurfaceReferenceImpl(parent_id, child_id);
   GarbageCollectSurfaces();
 }
 
+void SurfaceManager::PrintReferenceTree(const std::string& name) {
+  std::string str = "PrintReferenceTree[" + name + "]\n";
+  PrintReferenceTreeImpl(root_surface_id_, "  ", &str);
+  LOG(ERROR) << str;
+}
+
 size_t SurfaceManager::GetSurfaceReferenceCount(
     const SurfaceId& surface_id) const {
   auto iter = child_to_parent_refs_.find(surface_id);
   if (iter == child_to_parent_refs_.end())
     return 0;
   return iter->second.size();
 }
 
 size_t SurfaceManager::GetReferencedSurfaceCount(
     const SurfaceId& surface_id) const {
   auto iter = parent_to_child_refs_.find(surface_id);
   if (iter == parent_to_child_refs_.end())
     return 0;
   return iter->second.size();
 }
 
+void SurfaceManager::PrintReferenceTreeImpl(const SurfaceId& surface_id,
+                                            std::string indent,
+                                            std::string* str) {
+  Surface* surface = GetSurfaceForId(surface_id);
+  std::string description;
+  if (surface) {
+    if (surface->destroyed())
+      description = " destroyed ";
+    else
+      description = " live ";
+
+    if (surface->HasFrame()) {
+      description += surface->GetEligibleFrame()
+                         .render_pass_list[0]
+                         ->output_rect.size()
+                         .ToString();
+    }
+  }
+
+  *str += indent + surface_id.ToString() + description + "\n";
+  auto iter = parent_to_child_refs_.find(surface_id);
+  if (iter != parent_to_child_refs_.end()) {
+    const SurfaceIdSet& children = iter->second;
+    std::vector<SurfaceId> list(children.begin(), children.end());
+    std::sort(list.begin(), list.end());
+    for (const SurfaceId& child_id : list) {
+      PrintReferenceTreeImpl(child_id, indent + "  ", str);
+    }
+  }
+}
+
 void SurfaceManager::GarbageCollectSurfaces() {
   // Simple mark and sweep GC.
   // TODO(jbauman): Reduce the amount of work when nothing needs to be
   // destroyed.
   std::vector<SurfaceId> live_surfaces;
   std::unordered_set<SurfaceId, SurfaceIdHash> live_surfaces_set;
 
   // GC roots are surfaces that have not been destroyed, or have not had all
   // their destruction dependencies satisfied.
   for (auto& map_entry : surface_map_) {
@@ skipping 279 matching lines @@
 
 void SurfaceManager::SurfaceCreated(const SurfaceId& surface_id,
                                     const gfx::Size& frame_size,
                                     float device_scale_factor) {
   CHECK(thread_checker_.CalledOnValidThread());
   for (auto& observer : observer_list_)
     observer.OnSurfaceCreated(surface_id, frame_size, device_scale_factor);
 }
 
 }  // namespace cc