Add temporary reference ownership to SurfaceManager.

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>
@@ skipping 118 matching lines @@
   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);
+
+  if (using_surface_references()) {
+    // Remove any temporary references owned by |frame_sink_id|.
+    std::vector<SurfaceId> temp_refs_to_clear;
+    for (auto& map_entry : temporary_references_) {
+      base::Optional<FrameSinkId>& owner = map_entry.second;
+      if (owner.has_value() && owner.value() == frame_sink_id)
+        temp_refs_to_clear.push_back(map_entry.first);
+    }
+
+    for (auto& surface_id : temp_refs_to_clear)
+      RemoveTemporaryReference(surface_id, false);
+  }
+
   GarbageCollectSurfaces();
 }
 
 const SurfaceId& SurfaceManager::GetRootSurfaceId() const {
   return root_surface_id_;
 }
 
 void SurfaceManager::AddSurfaceReferences(
     const std::vector<SurfaceReference>& references) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(using_surface_references());
 
   for (const auto& reference : references)
     AddSurfaceReferenceImpl(reference.parent_id(), reference.child_id());
 }
 
 void SurfaceManager::RemoveSurfaceReferences(
     const std::vector<SurfaceReference>& references) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(using_surface_references());
 
   for (const auto& reference : references)
     RemoveSurfaceReferenceImpl(reference.parent_id(), reference.child_id());
 
   GarbageCollectSurfaces();
 }
 
+void SurfaceManager::AssignTemporaryReference(const SurfaceId& surface_id,
+                                              const FrameSinkId& owner) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(lifetime_type_, LifetimeType::REFERENCES);
+
+  if (!HasTemporaryReference(surface_id))
+    return;
+
+  temporary_references_[surface_id] = owner;
+}
+
+void SurfaceManager::DropTemporaryReference(const SurfaceId& surface_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(lifetime_type_, LifetimeType::REFERENCES);
+
+  if (!HasTemporaryReference(surface_id))
+    return;
+
+  RemoveTemporaryReference(surface_id, false);
+}
+
 void SurfaceManager::GarbageCollectSurfaces() {
   if (surfaces_to_destroy_.empty())
     return;
 
   SurfaceIdSet reachable_surfaces = using_surface_references()
                                         ? GetLiveSurfacesForReferences()
                                         : GetLiveSurfacesForSequences();
 
   std::vector<std::unique_ptr<Surface>> surfaces_to_delete;
 
@@ skipping 449 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