Decouple FrameSink Hierarchy registration from SurfaceFactoryClient registration

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/local_surface_id_allocator.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_info.h"
 
 #if DCHECK_IS_ON()
 #include <sstream>
 #endif
 
 namespace cc {
 
 SurfaceManager::FrameSinkSourceMapping::FrameSinkSourceMapping()
-    : client(nullptr), source(nullptr) {}
+    : source(nullptr) {}
 
 SurfaceManager::FrameSinkSourceMapping::FrameSinkSourceMapping(
     const FrameSinkSourceMapping& other) = default;
 
 SurfaceManager::FrameSinkSourceMapping::~FrameSinkSourceMapping() {
-  DCHECK(is_empty()) << "client: " << client
-                     << ", children: " << children.size();
 }
 
 SurfaceManager::SurfaceManager(LifetimeType lifetime_type)
     : lifetime_type_(lifetime_type),
       root_surface_id_(FrameSinkId(0u, 0u),
                        LocalSurfaceId(1u, base::UnguessableToken::Create())),
       weak_factory_(this) {
   thread_checker_.DetachFromThread();
   reference_factory_ =
       new DirectSurfaceReferenceFactory(weak_factory_.GetWeakPtr());
@@ skipping 10 matching lines @@
     GarbageCollectSurfaces();
   }
 
   for (SurfaceDestroyList::iterator it = surfaces_to_destroy_.begin();
        it != surfaces_to_destroy_.end();
        ++it) {
     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);
+  // All surface factory clients should be unregistered prior to SurfaceManager
+  // destruction.
+  DCHECK_EQ(clients_.size(), 0u);
   DCHECK_EQ(registered_sources_.size(), 0u);
 }
 
 #if DCHECK_IS_ON()
 std::string SurfaceManager::SurfaceReferencesToString() {
   std::stringstream str;
   SurfaceReferencesToStringImpl(root_surface_id_, "", &str);
   // Temporary references will have an asterisk in front of them.
   for (auto& map_entry : temporary_references_)
     SurfaceReferencesToStringImpl(map_entry.first, "* ", &str);
@@ skipping 315 matching lines @@
   if (frame_sink_temp_refs.empty())
     temporary_reference_ranges_.erase(frame_sink_id);
 }
 
 void SurfaceManager::RegisterSurfaceFactoryClient(
     const FrameSinkId& frame_sink_id,
     SurfaceFactoryClient* client) {
   DCHECK(client);
   DCHECK_EQ(valid_frame_sink_ids_.count(frame_sink_id), 1u);
 
-  // Will create a new FrameSinkSourceMapping for |frame_sink_id| if necessary.
-  FrameSinkSourceMapping& frame_sink_source =
-      frame_sink_source_map_[frame_sink_id];
-  DCHECK(!frame_sink_source.client);
-  frame_sink_source.client = client;
+  clients_[frame_sink_id] = client;
 
-  // Propagate any previously set sources to the new client.
-  if (frame_sink_source.source)
-    client->SetBeginFrameSource(frame_sink_source.source);
+  auto it = frame_sink_source_map_.find(frame_sink_id);
+  if (it != frame_sink_source_map_.end()) {
+    if (it->second.source)
+      client->SetBeginFrameSource(it->second.source);
+  }
 }
 
 void SurfaceManager::UnregisterSurfaceFactoryClient(
     const FrameSinkId& frame_sink_id) {
   DCHECK_EQ(valid_frame_sink_ids_.count(frame_sink_id), 1u);
-  DCHECK_EQ(frame_sink_source_map_.count(frame_sink_id), 1u);
+  auto client_iter = clients_.find(frame_sink_id);
+  DCHECK(client_iter != clients_.end());
 
-  auto iter = frame_sink_source_map_.find(frame_sink_id);
-  if (iter->second.source)
-    iter->second.client->SetBeginFrameSource(nullptr);
-  iter->second.client = nullptr;
-
-  // The SurfaceFactoryClient and hierarchy can be registered/unregistered
-  // in either order, so empty namespace_client_map entries need to be
-  // checked when removing either clients or relationships.
-  if (iter->second.is_empty())
-    frame_sink_source_map_.erase(iter);
+  auto source_iter = frame_sink_source_map_.find(frame_sink_id);
+  if (source_iter != frame_sink_source_map_.end()) {
+    if (source_iter->second.source)
+      client_iter->second->SetBeginFrameSource(nullptr);
+    if (!source_iter->second.has_children())
+      frame_sink_source_map_.erase(source_iter);
+  }
+  clients_.erase(client_iter);
 }
 
 void SurfaceManager::RegisterBeginFrameSource(
     BeginFrameSource* source,
     const FrameSinkId& frame_sink_id) {
   DCHECK(source);
   DCHECK_EQ(registered_sources_.count(source), 0u);
   DCHECK_EQ(valid_frame_sink_ids_.count(frame_sink_id), 1u);
 
   registered_sources_[source] = frame_sink_id;
@@ skipping 18 matching lines @@
   for (auto source_iter : registered_sources_)
     RecursivelyAttachBeginFrameSource(source_iter.second, source_iter.first);
 }
 
 void SurfaceManager::RecursivelyAttachBeginFrameSource(
     const FrameSinkId& frame_sink_id,
     BeginFrameSource* source) {
   FrameSinkSourceMapping& mapping = frame_sink_source_map_[frame_sink_id];
   if (!mapping.source) {
     mapping.source = source;
-    if (mapping.client)
-      mapping.client->SetBeginFrameSource(source);
+    auto client_iter = clients_.find(frame_sink_id);
+    if (client_iter != clients_.end())
+      client_iter->second->SetBeginFrameSource(source);
   }
   for (size_t i = 0; i < mapping.children.size(); ++i)
     RecursivelyAttachBeginFrameSource(mapping.children[i], source);
 }
 
 void SurfaceManager::RecursivelyDetachBeginFrameSource(
     const FrameSinkId& frame_sink_id,
     BeginFrameSource* source) {
   auto iter = frame_sink_source_map_.find(frame_sink_id);
   if (iter == frame_sink_source_map_.end())
     return;
   if (iter->second.source == source) {
     iter->second.source = nullptr;
-    if (iter->second.client)
-      iter->second.client->SetBeginFrameSource(nullptr);
+    auto client_iter = clients_.find(frame_sink_id);
+    if (client_iter != clients_.end())
+      client_iter->second->SetBeginFrameSource(nullptr);
   }
 
-  if (iter->second.is_empty()) {
+  if (!iter->second.has_children() && !clients_.count(frame_sink_id)) {
     frame_sink_source_map_.erase(iter);
     return;
   }
 
   std::vector<FrameSinkId>& children = iter->second.children;
   for (size_t i = 0; i < children.size(); ++i) {
     RecursivelyDetachBeginFrameSource(children[i], source);
   }
 }
 
@@ skipping 34 matching lines @@
   if (!parent_source)
     return;
 
   DCHECK_EQ(registered_sources_.count(parent_source), 1u);
   RecursivelyAttachBeginFrameSource(child_frame_sink_id, parent_source);
 }
 
 void SurfaceManager::UnregisterFrameSinkHierarchy(
     const FrameSinkId& parent_frame_sink_id,
     const FrameSinkId& child_frame_sink_id) {
-  // Deliberately do not check validity of either parent or child namespace
+  // Deliberately do not check validity of either parent or child FrameSinkId
   // here.  They were valid during the registration, so were valid at some
   // point in time.  This makes it possible to invalidate parent and child
-  // namespaces independently of each other and not have an ordering dependency
-  // of unregistering the hierarchy first before either of them.
+  // FrameSinkIds independently of each other and not have an ordering
+  // dependency  of unregistering the hierarchy first before either of them.
   DCHECK_EQ(frame_sink_source_map_.count(parent_frame_sink_id), 1u);
 
   auto iter = frame_sink_source_map_.find(parent_frame_sink_id);
 
   std::vector<FrameSinkId>& children = iter->second.children;
   bool found_child = false;
   for (size_t i = 0; i < children.size(); ++i) {
     if (children[i] == child_frame_sink_id) {
       found_child = true;
       children[i] = children.back();
       children.resize(children.size() - 1);
       break;
     }
   }
   DCHECK(found_child);
 
   // The SurfaceFactoryClient and hierarchy can be registered/unregistered
-  // in either order, so empty namespace_client_map entries need to be
+  // in either order, so empty frame_sink_source_map entries need to be
   // checked when removing either clients or relationships.
-  if (iter->second.is_empty()) {
+  if (!iter->second.has_children() && !clients_.count(parent_frame_sink_id)) {
     frame_sink_source_map_.erase(iter);
     return;
   }
 
   // If the parent does not have a begin frame source, then disconnecting it
   // will not change any of its children.
   BeginFrameSource* parent_source = iter->second.source;
   if (!parent_source)
     return;
 
@@ skipping 84 matching lines @@
     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