Surface Synchronization: Distinguish between dependencies and references

cc/surfaces/surface.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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 55 matching lines @@
 
   // Receive and track the resources referenced from the CompositorFrame
   // regardless of whether it's pending or active.
   factory_->ReceiveFromChild(frame.resource_list);
 
   if (!blocking_surfaces_.empty()) {
     pending_frame_ = std::move(frame);
     // Ask the surface manager to inform |this| when its dependencies are
     // resolved.
     factory_->manager()->RequestSurfaceResolution(this);
-
-    // We do not have to notify observers that referenced surfaces have changed
-    // in the else case because ActivateFrame will notify observers.
-    for (auto& observer : observers_) {
-      observer.OnReferencedSurfacesChanged(this, active_referenced_surfaces(),
-                                           pending_referenced_surfaces());
-    }
   } else {
     // If there are no blockers, then immediately activate the frame.
     ActivateFrame(std::move(frame));
   }
 
   // Returns resources for the previous pending frame.
   if (previous_pending_frame)
     UnrefFrameResources(*previous_pending_frame);
 
   if (!draw_callback_.is_null())
@@ skipping 97 matching lines @@
   if (!active_frame_->render_pass_list.empty())
     ++frame_index_;
 
   previous_frame_surface_id_ = surface_id();
 
   if (previous_frame)
     UnrefFrameResources(*previous_frame);
 
   for (auto& observer : observers_)
     observer.OnSurfaceActivated(this);
-
-  for (auto& observer : observers_) {
-    observer.OnReferencedSurfacesChanged(this, active_referenced_surfaces(),
-                                         pending_referenced_surfaces());
-  }
 }
 
 void Surface::UpdateBlockingSurfaces(
     const base::Optional<CompositorFrame>& previous_pending_frame,
     const CompositorFrame& current_frame) {
   // If there is no SurfaceDependencyTracker installed then the |current_frame|
   // does not block on anything.
   if (!factory_->manager()->dependency_tracker()) {
     blocking_surfaces_.clear();
     return;
@@ skipping 123 matching lines @@
     frame->metadata.latency_info.swap(*latency_info);
     return;
   }
   std::copy(frame->metadata.latency_info.begin(),
             frame->metadata.latency_info.end(),
             std::back_inserter(*latency_info));
   frame->metadata.latency_info.clear();
 }
 
 }  // namespace cc