Add SurfaceManager option to use references exclusively.

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/surface.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_id_allocator.h"
 
 namespace cc {
 
 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();
 }
 
-SurfaceManager::SurfaceManager()
-    : kRootSurfaceId(FrameSinkId(0u, 0u),
-                     LocalFrameId(0u, base::UnguessableToken::Create())) {
+SurfaceManager::SurfaceManager(bool use_references)
+    : use_references_(use_references),
+      root_surface_id_(FrameSinkId(0u, 0u),
+                       LocalFrameId(1u, base::UnguessableToken::Create())) {

[vmpstr, 2016/12/01 21:04:02]

Why 1u change?

[kylechar, 2016/12/01 22:49:58]

The LocalFrameId will be a valid value (local_frame.is_valid()) this way.
Realistically, it doesn't make a difference but seems nicer for consistency.

   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 24 matching lines @@
 void SurfaceManager::Destroy(std::unique_ptr<Surface> surface) {
   DCHECK(thread_checker_.CalledOnValidThread());
   surface->set_destroyed(true);
   surfaces_to_destroy_.push_back(std::move(surface));
   GarbageCollectSurfaces();
 }
 
 void SurfaceManager::DidSatisfySequences(const FrameSinkId& frame_sink_id,
                                          std::vector<uint32_t>* sequence) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!use_references_);
   for (uint32_t value : *sequence)
     satisfied_sequences_.insert(SurfaceSequence(frame_sink_id, value));
   sequence->clear();
   GarbageCollectSurfaces();
 }
 
 void SurfaceManager::RegisterFrameSinkId(const FrameSinkId& frame_sink_id) {
   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;
   }
-  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;
   }
   if (surface_map_.count(child_id) == 0) {
     LOG(ERROR) << "No surface in map for " << child_id.ToString();
     return;
   }
 
   parent_to_child_refs_[parent_id].insert(child_id);
   child_to_parent_refs_[child_id].insert(parent_id);
@@ skipping 25 matching lines @@
 }
 
 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::GarbageCollectSurfacesFromRoot() {
+  DCHECK(use_references_);
+
+  if (surfaces_to_destroy_.empty())
+    return;
+
+  std::unordered_set<SurfaceId, SurfaceIdHash> reachable_surfaces;
+
+  // Walk down from the root and mark each SurfaceId we encounter as reachable.
+  std::queue<SurfaceId> surface_queue({root_surface_id_});

[vmpstr, 2016/12/01 21:04:02]

surface_queue{root_surface_id_}?

Can you also verify in the styleguide that brace/initializer list things like
that are allowed? (afaik it is, but doesn't hurt to check)

[kylechar, 2016/12/01 22:49:58]

std::initializer_list are allowed now and I can't see anything against using it
this way in the style guide.

+  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|.
+        if (reachable_surfaces.insert(child_id).second)
+          surface_queue.push(child_id);
+      }
+    }
+    surface_queue.pop();
+  }
+
+  std::vector<std::unique_ptr<Surface>> surfaces_to_delete;
+
+  // Delete all destroyed and unreachable surfaces.
+  for (auto iter = surfaces_to_destroy_.begin();
+       iter != surfaces_to_destroy_.end();) {
+    SurfaceId surface_id = (*iter)->surface_id();
+    if (reachable_surfaces.count(surface_id) == 0) {
+      DeregisterSurface(surface_id);
+      surfaces_to_delete.push_back(std::move(*iter));
+      iter = surfaces_to_destroy_.erase(iter);
+    } else {
+      ++iter;
+    }
+  }
+
+  // ~Surface() draw callback could modify |surfaces_to_destroy_|.
+  surfaces_to_delete.clear();
+}
+
 void SurfaceManager::GarbageCollectSurfaces() {
+  if (use_references_) {
+    GarbageCollectSurfacesFromRoot();
+    return;
+  }
+
   // 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_) {
     const SurfaceId& surface_id = map_entry.first;
@@ skipping 278 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