[WIP] cc: Plumb SurfaceId from clients

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 "base/logging.h"
@@ skipping 29 matching lines @@
 
   // All hierarchies, sources, and surface factory clients should be
   // unregistered prior to SurfaceManager destruction.
   DCHECK_EQ(namespace_client_map_.size(), 0u);
   DCHECK_EQ(registered_sources_.size(), 0u);
 }
 
 void SurfaceManager::RegisterSurface(Surface* surface) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface);
-  DCHECK(!surface_map_.count(surface->surface_id()));
+  // We may submit a new CompositorFrame with the same surface ID
+  // before the previous one has been garbage collected.
   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);
-  DCHECK(it != surface_map_.end());
+  if (it == surface_map_.end())
+    return;
   surface_map_.erase(it);
 }
 
 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(uint32_t client_id,
                                          std::vector<uint32_t>* sequence) {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (std::vector<uint32_t>::iterator it = sequence->begin();
        it != sequence->end();
        ++it) {
     satisfied_sequences_.insert(SurfaceSequence(client_id, *it));
   }
   sequence->clear();
   GarbageCollectSurfaces();
 }
 
-void SurfaceManager::RegisterSurfaceClientId(uint32_t client_id) {
-  bool inserted = valid_surface_client_ids_.insert(client_id).second;
-  DCHECK(inserted);
-}
-
-void SurfaceManager::InvalidateSurfaceClientId(uint32_t client_id) {
-  valid_surface_client_ids_.erase(client_id);
-  GarbageCollectSurfaces();
-}
-
 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::set<SurfaceId> 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 35 matching lines @@
       dest_it = surfaces_to_destroy_.erase(dest_it);
       to_destroy.push_back(std::move(surf));
     } else {
       ++dest_it;
     }
   }
 
   to_destroy.clear();
 }
 
-void SurfaceManager::RegisterSurfaceFactoryClient(
-    uint32_t client_id,
-    SurfaceFactoryClient* client) {
+void SurfaceManager::RegisterClient(uint32_t client_id,
+                                    SurfaceFactoryClient* client) {
   DCHECK(client);
+  bool inserted = valid_surface_client_ids_.insert(client_id).second;
+  DCHECK(inserted);
   DCHECK(!namespace_client_map_[client_id].client);
-  DCHECK_EQ(valid_surface_client_ids_.count(client_id), 1u);
 
   auto iter = namespace_client_map_.find(client_id);
   if (iter == namespace_client_map_.end()) {
     auto insert_result = namespace_client_map_.insert(
         std::make_pair(client_id, ClientSourceMapping()));
     DCHECK(insert_result.second);
     iter = insert_result.first;
   }
   iter->second.client = client;
 
   // Propagate any previously set sources to the new client.
   if (iter->second.source)
     client->SetBeginFrameSource(iter->second.source);
 }
 
-void SurfaceManager::UnregisterSurfaceFactoryClient(uint32_t client_id) {
+void SurfaceManager::UnregisterClient(uint32_t client_id) {
   DCHECK_EQ(valid_surface_client_ids_.count(client_id), 1u);
   DCHECK_EQ(namespace_client_map_.count(client_id), 1u);
 
   auto iter = namespace_client_map_.find(client_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())
     namespace_client_map_.erase(iter);
+
+  valid_surface_client_ids_.erase(client_id);
+  GarbageCollectSurfaces();
 }
 
 void SurfaceManager::RegisterBeginFrameSource(BeginFrameSource* source,
                                               uint32_t client_id) {
   DCHECK(source);
   DCHECK_EQ(registered_sources_.count(source), 0u);
   DCHECK_EQ(valid_surface_client_ids_.count(client_id), 1u);
 
   registered_sources_[source] = client_id;
   RecursivelyAttachBeginFrameSource(client_id, source);
@@ skipping 151 matching lines @@
 
 bool SurfaceManager::SurfaceModified(const SurfaceId& surface_id) {
   CHECK(thread_checker_.CalledOnValidThread());
   bool changed = false;
   FOR_EACH_OBSERVER(SurfaceDamageObserver, observer_list_,
                     OnSurfaceDamaged(surface_id, &changed));
   return changed;
 }
 
 }  // namespace cc