[cc] Plumb BeginFrameAcks through SurfaceManager to DisplayScheduler.

cc/surfaces/display_scheduler.cc

Index: cc/surfaces/display_scheduler.cc
diff --git a/cc/surfaces/display_scheduler.cc b/cc/surfaces/display_scheduler.cc
index 40e80bf97bd36034d435bbe34c3b4242295cccd4..2db33a798f755f1f6eaba36af8b6357f58bc75ee 100644
--- a/cc/surfaces/display_scheduler.cc
+++ b/cc/surfaces/display_scheduler.cc
@@ -10,6 +10,7 @@
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/output/output_surface.h"
+#include "cc/surfaces/surface_manager.h"
 
 namespace cc {
 
@@ -17,6 +18,7 @@ DisplayScheduler::DisplayScheduler(base::SingleThreadTaskRunner* task_runner,
                                    int max_pending_swaps)
     : client_(nullptr),
       begin_frame_source_(nullptr),
+      surface_manager_(nullptr),
       task_runner_(task_runner),
       inside_surface_damaged_(false),
       visible_(false),
@@ -25,13 +27,11 @@ DisplayScheduler::DisplayScheduler(base::SingleThreadTaskRunner* task_runner,
       inside_begin_frame_deadline_interval_(false),
       needs_draw_(false),
       expecting_root_surface_damage_because_of_resize_(false),
-      all_active_child_surfaces_ready_to_draw_(false),
+      has_pending_surfaces_(false),
       next_swap_id_(1),
       pending_swaps_(0),
       max_pending_swaps_(max_pending_swaps),
       observing_begin_frame_source_(false),
-      root_surface_damaged_(false),
-      expect_damage_from_root_surface_(false),
       weak_ptr_factory_(this) {
   begin_frame_deadline_closure_ = base::Bind(
       &DisplayScheduler::OnBeginFrameDeadline, weak_ptr_factory_.GetWeakPtr());
@@ -50,6 +50,10 @@ void DisplayScheduler::SetBeginFrameSource(
   begin_frame_source_ = begin_frame_source;
 }
 
+void DisplayScheduler::SetSurfaceManager(SurfaceManager* surface_manager) {
+  surface_manager_ = surface_manager;
+}
+
 void DisplayScheduler::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
@@ -81,7 +85,6 @@ void DisplayScheduler::ForceImmediateSwapIfPossible() {
 
 void DisplayScheduler::DisplayResized() {
   expecting_root_surface_damage_because_of_resize_ = true;
-  expect_damage_from_root_surface_ = true;
   needs_draw_ = true;
   ScheduleBeginFrameDeadline();
 }
@@ -108,21 +111,45 @@ void DisplayScheduler::SurfaceDamaged(const SurfaceId& surface_id) {
 
   needs_draw_ = true;
 
-  if (surface_id == root_surface_id_) {
-    root_surface_damaged_ = true;
+  if (surface_id == root_surface_id_)
     expecting_root_surface_damage_because_of_resize_ = false;
-  } else {
-    child_surface_ids_damaged_.insert(surface_id);
-
-    // TODO(mithro): Use hints from SetNeedsBeginFrames and SwapAborts.
-    all_active_child_surfaces_ready_to_draw_ = base::STLIncludes(
-        child_surface_ids_damaged_, child_surface_ids_to_expect_damage_from_);
-  }
 
   StartObservingBeginFrames();
   ScheduleBeginFrameDeadline();
 }
 
+void DisplayScheduler::OnSurfaceProducerStateChanged(
+    const SurfaceId& surface_id) {
+  UpdateHasPendingSurfaces();
+  TRACE_EVENT1("cc", "DisplayScheduler::OnSurfaceProducerStateChanged",
+               "has_pending_surfaces", has_pending_surfaces_);
+  ScheduleBeginFrameDeadline();
+}
+
+void DisplayScheduler::UpdateHasPendingSurfaces() {
+  if (!surface_manager_)
+    return;
+
+  // We only need to check for the state of previously referenced surfaced, as
+  // newly referenced child surfaces will already have damage. (An exception to
+  // this are surfaces referenced by a CompositorFrame that is activated because
+  // of a surface synchronization deadline. By activating the parent frame,
+  // however, we decided not to wait for these child surfaces.)
+  for (std::pair<SurfaceId, int> entry :
+       client_->GetPreviousContainedSurfaces()) {
+    Surface* surface = surface_manager_->GetSurfaceForId(entry.first);
+    if (surface && surface->GetProducerState() == Surface::PENDING) {
+      TRACE_EVENT2("cc", "DisplayScheduler::UpdateHasPendingSurfaces()",
+                   "pending_surface_id", entry.first.ToString(),
+                   "pending_surface_producer_state",
+                   surface->GetProducerState());
+      has_pending_surfaces_ = true;
+      return;
+    }
+  }
+  has_pending_surfaces_ = false;
+}
+
 void DisplayScheduler::OutputSurfaceLost() {
   TRACE_EVENT0("cc", "DisplayScheduler::OutputSurfaceLost");
   output_surface_lost_ = true;
@@ -138,19 +165,7 @@ bool DisplayScheduler::DrawAndSwap() {
   if (!success)
     return false;
 
-  child_surface_ids_to_expect_damage_from_ =
-      base::STLSetIntersection<std::vector<SurfaceId>>(
-          child_surface_ids_damaged_, child_surface_ids_damaged_prev_);
-
-  child_surface_ids_damaged_prev_.swap(child_surface_ids_damaged_);
-  child_surface_ids_damaged_.clear();
-
   needs_draw_ = false;
-  all_active_child_surfaces_ready_to_draw_ =
-      child_surface_ids_to_expect_damage_from_.empty();
-
-  expect_damage_from_root_surface_ = root_surface_damaged_;
-  root_surface_damaged_ = false;
   return true;
 }
 
@@ -243,7 +258,9 @@ base::TimeTicks DisplayScheduler::DesiredBeginFrameDeadlineTime() {
            current_begin_frame_args_.interval;
   }
 
-  if (!needs_draw_) {
+  bool all_surfaces_ready =
+      !has_pending_surfaces_ && root_surface_id_.is_valid();
+  if (!needs_draw_ && !all_surfaces_ready) {
     TRACE_EVENT_INSTANT0("cc", "No damage yet", TRACE_EVENT_SCOPE_THREAD);
     return current_begin_frame_args_.frame_time +
            current_begin_frame_args_.interval;
@@ -256,10 +273,7 @@ base::TimeTicks DisplayScheduler::DesiredBeginFrameDeadlineTime() {
            current_begin_frame_args_.interval;
   }
 
-  bool root_ready_to_draw =
-      !expect_damage_from_root_surface_ || root_surface_damaged_;
-
-  if (all_active_child_surfaces_ready_to_draw_ && root_ready_to_draw) {
+  if (all_surfaces_ready && !expecting_root_surface_damage_because_of_resize_) {
     TRACE_EVENT_INSTANT0("cc", "All active surfaces ready",
                          TRACE_EVENT_SCOPE_THREAD);
     return base::TimeTicks();
@@ -273,27 +287,6 @@ base::TimeTicks DisplayScheduler::DesiredBeginFrameDeadlineTime() {
            current_begin_frame_args_.interval;
   }
 
-  // Use an earlier deadline if we are only waiting for the root surface
-  // in case our expect_damage_from_root_surface heuristic is incorrect.
-  // TODO(mithro): Replace this with SetNeedsBeginFrame and SwapAbort
-  // logic.
-  if (all_active_child_surfaces_ready_to_draw_ &&
-      expect_damage_from_root_surface_) {
-    TRACE_EVENT_INSTANT0("cc", "Waiting for damage from root surface",
-                         TRACE_EVENT_SCOPE_THREAD);
-    // This adjusts the deadline by DefaultEstimatedParentDrawTime for
-    // a second time. The first one represented the Surfaces draw to display
-    // latency. This one represents root surface commit+raster+draw latency.
-    // We treat the root surface differently since it lives on the same thread
-    // as Surfaces and waiting for it too long may push out the Surfaces draw.
-    // If we also assume the root surface is fast to start a commit after the
-    // beginning of a frame, it'll have a chance to lock its resources, which
-    // will cause us to wait for it to unlock its resources above.
-    // TODO(mithro): Replace hard coded estimates.
-    return current_begin_frame_args_.deadline -
-           BeginFrameArgs::DefaultEstimatedParentDrawTime();
-  }
-
   TRACE_EVENT_INSTANT0("cc", "More damage expected soon",
                        TRACE_EVENT_SCOPE_THREAD);
   return current_begin_frame_args_.deadline;
@@ -344,11 +337,9 @@ bool DisplayScheduler::AttemptDrawAndSwap() {
       return DrawAndSwap();
   } else {
     // We are going idle, so reset expectations.
-    child_surface_ids_to_expect_damage_from_.clear();
-    child_surface_ids_damaged_prev_.clear();
-    child_surface_ids_damaged_.clear();
-    all_active_child_surfaces_ready_to_draw_ = true;
-    expect_damage_from_root_surface_ = false;
+    // TODO(eseckler): Should we avoid going idle if
+    // |expecting_root_surface_damage_because_of_resize_| is true?
+    expecting_root_surface_damage_because_of_resize_ = false;
 
     StopObservingBeginFrames();
   }