Add temporary reference ownership to SurfaceManager.

cc/surfaces/surface_manager.h

 // 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.
 
 #ifndef CC_SURFACES_SURFACE_MANAGER_H_
 #define CC_SURFACES_SURFACE_MANAGER_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 129 matching lines @@
   const SurfaceId& GetRootSurfaceId() const;
 
   // Adds all surface references in |references|. This will remove any temporary
   // references for child surface in a surface reference.
   void AddSurfaceReferences(const std::vector<SurfaceReference>& references);
 
   // Removes all surface references in |references| then runs garbage
   // collection to delete unreachable surfaces.
   void RemoveSurfaceReferences(const std::vector<SurfaceReference>& references);
 
+  // Assigns |frame_sink_id| as the owner of the temporary reference to
+  // |surface_id|. If |frame_sink_id| is invalidated the temporary reference
+  // will be removed. If a surface reference has already been added from the
+  // parent to |surface_id| then this will do nothing.
+  void AssignTemporaryReference(const SurfaceId& surface_id,
+                                const FrameSinkId& owner);
+
+  // Drops the temporary reference for |surface_id|. If a surface reference has
+  // already been added from the parent to |surface_id| then this will do
+  // nothing.
+  void DropTemporaryReference(const SurfaceId& surface_id);
+
   scoped_refptr<SurfaceReferenceFactory> reference_factory() {
     return reference_factory_;
   }
 
   bool using_surface_references() const {
     return lifetime_type_ == LifetimeType::REFERENCES;
   }
 
  private:
   friend class test::CompositorFrameSinkSupportTest;
@@ skipping 28 matching lines @@
   // Removes a reference from a |parent_id| to |child_id|.
   void RemoveSurfaceReferenceImpl(const SurfaceId& parent_id,
                                   const SurfaceId& child_id);
 
   // Removes all surface references to or from |surface_id|. Used when the
   // surface is about to be deleted.
   void RemoveAllSurfaceReferences(const SurfaceId& surface_id);
 
   bool HasTemporaryReference(const SurfaceId& surface_id) const;
 
-  // Adds a temporary reference to |surface_id|.
+  // Adds a temporary reference to |surface_id|. The reference will not have an
+  // owner initially.
   void AddTemporaryReference(const SurfaceId& surface_id);
 
   // Removes temporary reference to |surface_id|. If |remove_range| is true then
   // all temporary references to surfaces with the same FrameSinkId as
   // |surface_id| that were added before |surface_id| will also be removed.
   void RemoveTemporaryReference(const SurfaceId& surface_id, bool remove_range);
 
 #if DCHECK_IS_ON()
   // Recursively prints surface references starting at |surface_id| to |str|.
   void SurfaceReferencesToStringImpl(const SurfaceId& surface_id,
@@ skipping 57 matching lines @@
 
   // Root SurfaceId that references display root surfaces. There is no Surface
   // with this id, it's for bookkeeping purposes only.
   const SurfaceId root_surface_id_;
 
   // The DirectSurfaceReferenceFactory that uses this manager to create surface
   // references.
   scoped_refptr<SurfaceReferenceFactory> reference_factory_;
 
   // A map of surfaces that have temporary references to them. The key is the
-  // SurfaceId and the value is the owner.
-  // TODO(kylechar): Use owner value.
+  // SurfaceId and the value is the owner. The owner will initially be empty and
+  // set later by AssignTemporaryReference().
   std::unordered_map<SurfaceId, base::Optional<FrameSinkId>, SurfaceIdHash>
       temporary_references_;
 
   // Range tracking information for temporary references. Each map entry is an
   // is an ordered list of SurfaceIds that have temporary references with the
   // same FrameSinkId. A SurfaceId can be reconstructed with:
   //   SurfaceId surface_id(key, value[index]);
   // The LocalSurfaceIds are stored in the order the surfaces are created in. If
   // a reference is added to a later SurfaceId then all temporary references up
   // to that point will be removed. This is to handle clients getting out of
   // sync, for example the embedded client producing new SurfaceIds faster than
   // the embedding client can use them.
   std::unordered_map<FrameSinkId, std::vector<LocalSurfaceId>, FrameSinkIdHash>
       temporary_reference_ranges_;
 
   std::unique_ptr<SurfaceDependencyTracker> dependency_tracker_;
 
   base::WeakPtrFactory<SurfaceManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_SURFACES_SURFACE_MANAGER_H_