Surface synchronization: Immediately activate late arriving CompositorFrames

cc/surfaces/surface_dependency_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/surface_dependency_tracker.h"
 
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_info.h"
 #include "cc/surfaces/surface_manager.h"
 
@@ skipping 20 matching lines @@
     DCHECK(observed_surface);
     observed_surface->RemoveObserver(this);
   }
   observed_surfaces_by_id_.clear();
 }
 
 void SurfaceDependencyTracker::RequestSurfaceResolution(Surface* surface) {
   DCHECK(surface->HasPendingFrame());
 
   const CompositorFrame& pending_frame = surface->GetPendingFrame();
-  bool needs_begin_frame =
-      pending_frame.metadata.can_activate_before_dependencies;
+  bool needs_deadline = pending_frame.metadata.can_activate_before_dependencies;
+
+  auto late_it = late_surfaces_by_id_.find(surface->surface_id());
+  if (needs_deadline && late_it != late_surfaces_by_id_.end()) {
+    late_surfaces_by_id_.erase(late_it);
+    surface->ActivatePendingFrameForDeadline();
+    return;
+  }
 
   // Referenced surface IDs that aren't currently known to the surface manager
   // or do not have an active CompsotiorFrame block this frame.
   for (const SurfaceId& surface_id : pending_frame.metadata.embedded_surfaces) {
     Surface* surface_dependency = surface_manager_->GetSurfaceForId(surface_id);
     if (!surface_dependency || !surface_dependency->HasActiveFrame())
       blocked_surfaces_from_dependency_[surface_id].insert(
           surface->surface_id());
   }
 
   if (!observed_surfaces_by_id_.count(surface->surface_id())) {
     surface->AddObserver(this);
     observed_surfaces_by_id_.insert(surface->surface_id());
   }
 
-  if (needs_begin_frame && !frames_since_deadline_set_)
+  if (needs_deadline && !frames_since_deadline_set_)
     frames_since_deadline_set_ = 0;
 }
 
 void SurfaceDependencyTracker::OnBeginFrame(const BeginFrameArgs& args) {
   // If no deadline is set then we have nothing to do.
   if (!frames_since_deadline_set_)
     return;
 
   // TODO(fsamuel, kylechar): We have a single global deadline here. We should
   // scope deadlines to surface subtrees. We cannot do that until
   // SurfaceReferences have been fully implemented
   // (see https://crbug.com/689719).
   last_begin_frame_args_ = args;
   // Nothing to do if we haven't hit a deadline yet.
   if (++(*frames_since_deadline_set_) != kMaxBeginFrameCount)
     return;
 
+  late_surfaces_by_id_.clear();
+
   // Activate all surfaces that respect the deadline.
   // Copy the set of blocked surfaces here because that set can mutate as we
   // activate CompositorFrames: an activation can trigger further activations
   // which will remove elements from |observed_surfaces_by_id_|. This
   // invalidates the iterator.
   base::flat_set<SurfaceId> blocked_surfaces_by_id(observed_surfaces_by_id_);
   for (const SurfaceId& surface_id : blocked_surfaces_by_id) {
     Surface* blocked_surface = surface_manager_->GetSurfaceForId(surface_id);
     if (!blocked_surface) {
       // A blocked surface may have been garbage collected during dependency
       // resolution.
       DCHECK(!observed_surfaces_by_id_.count(surface_id));
       continue;
     }
     // Clear all tracked blockers for |blocked_surface|.
     for (const SurfaceId& blocking_surface_id :
-         blocked_surface->blocking_surfaces())
+         blocked_surface->blocking_surfaces()) {
+      // If we are not activating this blocker now, then it's late.
+      if (!blocked_surfaces_by_id.count(blocking_surface_id))
+        late_surfaces_by_id_.insert(blocking_surface_id);
       blocked_surfaces_from_dependency_[blocking_surface_id].erase(surface_id);
+    }
     blocked_surface->ActivatePendingFrameForDeadline();
   }
 
   frames_since_deadline_set_.reset();
 }
 
 const BeginFrameArgs& SurfaceDependencyTracker::LastUsedBeginFrameArgs() const {
   return last_begin_frame_args_;
 }
 
@@ skipping 98 matching lines @@
       // A blocked surface may have been garbage collected during dependency
       // resolution.
       DCHECK(!observed_surfaces_by_id_.count(blocked_surface_by_id));
       continue;
     }
     blocked_surface->NotifySurfaceIdAvailable(surface_id);
   }
 }
 
 }  // namespace cc