Surface Synchronization: Distinguish between dependencies and references

cc/surfaces/referenced_surface_tracker.cc

 // Copyright 2016 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/referenced_surface_tracker.h"
 
 #include <utility>
 
 #include "base/logging.h"
 
 namespace cc {
 
 ReferencedSurfaceTracker::ReferencedSurfaceTracker(
     const FrameSinkId& frame_sink_id)
     : current_surface_id_(frame_sink_id, LocalSurfaceId()) {
   DCHECK(current_surface_id_.frame_sink_id().is_valid());
 }
 
 ReferencedSurfaceTracker::~ReferencedSurfaceTracker() {}
 
 void ReferencedSurfaceTracker::UpdateReferences(
     const LocalSurfaceId& local_surface_id,
-    const std::vector<SurfaceId>* active_referenced_surfaces,
-    const std::vector<SurfaceId>* pending_referenced_surfaces) {
+    const std::vector<SurfaceId>* active_referenced_surfaces) {
   DCHECK(local_surface_id.is_valid());
 
   // Clear references to add/remove from the last frame.
   references_to_remove_.clear();
   references_to_add_.clear();
 
   // If |current_surface_id_| is changing then update |current_surface_id_|.
   // Also clear |referenced_surfaces_| because we haven't added any references
   // from the new SurfaceId yet.
   if (current_surface_id_.local_surface_id() != local_surface_id) {
     current_surface_id_ =
         SurfaceId(current_surface_id_.frame_sink_id(), local_surface_id);
     referenced_surfaces_.clear();
   }
 
   std::unordered_set<SurfaceId, SurfaceIdHash> referenced_surface_set;
   if (active_referenced_surfaces) {
     referenced_surface_set.insert(active_referenced_surfaces->begin(),
                                   active_referenced_surfaces->end());
   }
 
-  if (pending_referenced_surfaces) {
-    referenced_surface_set.insert(pending_referenced_surfaces->begin(),
-                                  pending_referenced_surfaces->end());
-  }
-
   ProcessNewReferences(referenced_surface_set);
 }
 
 void ReferencedSurfaceTracker::ProcessNewReferences(
     const std::unordered_set<SurfaceId, SurfaceIdHash>&
         new_referenced_surfaces) {
   // Removed references for each SurfaceId in |referenced_surfaces_| if they
   // aren't referenced anymore. Removing from a set invalidates iterators, so
   // create a new vector then remove everything in it.
   std::vector<SurfaceId> not_referenced;
@@ skipping 20 matching lines @@
 }
 
 void ReferencedSurfaceTracker::RemoveSurfaceReference(
     const SurfaceId& surface_id) {
   references_to_remove_.push_back(
       SurfaceReference(current_surface_id_, surface_id));
   referenced_surfaces_.erase(surface_id);
 }
 
 }  // namespace cc