Adds BeginFrameControl via DevTools.

cc/surfaces/display_scheduler.cc

 // Copyright 2015 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/display_scheduler.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
+#include "cc/output/begin_frame_args.h"
 #include "cc/output/output_surface.h"
 
 namespace cc {
 
-DisplayScheduler::DisplayScheduler(BeginFrameSource* begin_frame_source,
-                                   base::SingleThreadTaskRunner* task_runner,
+DisplayScheduler::DisplayScheduler(base::SingleThreadTaskRunner* task_runner,
                                    int max_pending_swaps)
-    : begin_frame_source_(begin_frame_source),
+    : client_(nullptr),
+      begin_frame_source_(nullptr),
       task_runner_(task_runner),
       inside_surface_damaged_(false),
       visible_(false),
       output_surface_lost_(false),
       root_surface_resources_locked_(true),
       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),
       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());
 }
 
 DisplayScheduler::~DisplayScheduler() {
   StopObservingBeginFrames();
 }
 
 void DisplayScheduler::SetClient(DisplaySchedulerClient* client) {
   client_ = client;
 }
 
+void DisplayScheduler::SetBeginFrameSource(
+    DisplayBeginFrameSource* begin_frame_source) {
+  begin_frame_source_ = begin_frame_source;
+  begin_frame_source_->SetClient(this);
+  DCHECK(begin_frame_source_->GetTargetSource());
+}
+
 void DisplayScheduler::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   // If going invisible, we'll stop observing begin frames once we try
   // to draw and fail.
   StartObservingBeginFrames();
   ScheduleBeginFrameDeadline();
 }
 
 // If we try to draw when the root surface resources are locked, the
 // draw will fail.
 void DisplayScheduler::SetRootSurfaceResourcesLocked(bool locked) {
   TRACE_EVENT1("cc", "DisplayScheduler::SetRootSurfaceResourcesLocked",
                "locked", locked);
   root_surface_resources_locked_ = locked;
   ScheduleBeginFrameDeadline();
 }
 
 // This is used to force an immediate swap before a resize.
 void DisplayScheduler::ForceImmediateSwapIfPossible() {
   TRACE_EVENT0("cc", "DisplayScheduler::ForceImmediateSwapIfPossible");
   bool in_begin = inside_begin_frame_deadline_interval_;
   AttemptDrawAndSwap();
   if (in_begin)
-    begin_frame_source_->DidFinishFrame(this, 0);
+    begin_frame_source_->GetTargetSource()->DidFinishFrame(this, 0);
 }
 
 void DisplayScheduler::DisplayResized() {
   expecting_root_surface_damage_because_of_resize_ = true;
   expect_damage_from_root_surface_ = true;
   needs_draw_ = true;
   ScheduleBeginFrameDeadline();
 }
 
 // Notification that there was a resize or the root surface changed and
@@ skipping 17 matching lines @@
   base::AutoReset<bool> auto_reset(&inside_surface_damaged_, true);
 
   needs_draw_ = true;
 
   if (surface_id == root_surface_id_) {
     root_surface_damaged_ = true;
     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_);
+    if (BeginFrameForcesDamage()) {
+      // Wait for all BeginFrameObservers to call DidFinishFrame() before
+      // triggering an early deadline. We do this only if we know that the
+      // BeginFrame should cause damage on all active surfaces, because BFOs
+      // currently may not call DidFinishFrame() when the BeginFrame does not
+      // cause any damage to their surface.
+      // TODO(eseckler): Make this the default heuristic once we can guarantee
+      // observers to call DidFinishFrame() for every frame.
+      all_active_child_surfaces_ready_to_draw_ =
+          begin_frame_source_->AllObserversFinishedFrame();
+    } else {
+      // 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::OutputSurfaceLost() {
   TRACE_EVENT0("cc", "DisplayScheduler::OutputSurfaceLost");
   output_surface_lost_ = true;
   ScheduleBeginFrameDeadline();
@@ skipping 57 matching lines @@
   // synchronously trigger the previous deadline before progressing.
   if (inside_begin_frame_deadline_interval_) {
     OnBeginFrameDeadline();
   }
 
   // Schedule the deadline.
   current_begin_frame_args_ = save_args;
   current_begin_frame_args_.deadline -=
       BeginFrameArgs::DefaultEstimatedParentDrawTime();
   inside_begin_frame_deadline_interval_ = true;
+
+  if (BeginFrameForcesDamage()) {
+    // We know every surface that receives the BeginFrame will be damaged, so we
+    // wait until all BeginFrameObservers have responded instead of waiting for
+    // child_surface_ids_to_expect_damage_from_.
+    expect_damage_from_root_surface_ = false;
+    all_active_child_surfaces_ready_to_draw_ =
+        begin_frame_source_->AllObserversFinishedFrame();
+  }
+
   ScheduleBeginFrameDeadline();
-
   return true;
 }
 
 void DisplayScheduler::StartObservingBeginFrames() {
   if (!observing_begin_frame_source_ && ShouldDraw()) {
-    begin_frame_source_->AddObserver(this);
+    // We don't want to wait for our own DidFinishFrame() when using
+    // begin_frame_source_->AllObserversFinishedFrame(), so we add ourselves to
+    // the target source directly.
+    begin_frame_source_->GetTargetSource()->AddObserver(this);
     observing_begin_frame_source_ = true;
   }
 }
 
 void DisplayScheduler::StopObservingBeginFrames() {
   if (observing_begin_frame_source_) {
-    begin_frame_source_->RemoveObserver(this);
+    begin_frame_source_->GetTargetSource()->RemoveObserver(this);
     observing_begin_frame_source_ = false;
 
     // A missed BeginFrame may be queued, so drop that too if we're going to
     // stop listening.
     missed_begin_frame_task_.Cancel();
   }
 }
 
 bool DisplayScheduler::ShouldDraw() {
   // Note: When any of these cases becomes true, StartObservingBeginFrames must
   // be called to ensure the draw will happen.
   return needs_draw_ && !output_surface_lost_ && visible_;
 }
 
+bool DisplayScheduler::BeginFrameForcesDamage() const {
+  return !current_begin_frame_args_.allow_latency_optimizations;
+}
+
 void DisplayScheduler::OnBeginFrameSourcePausedChanged(bool paused) {
   // BeginFrameSources used with DisplayScheduler do not make use of this
   // feature.
   if (paused)
     NOTIMPLEMENTED();
 }
 
+void DisplayScheduler::ObserverStatusChanged() {
+  // If we're using the BeginFrameObservers to determine when all active
+  // surfaces have been damaged, we may need to update the deadline.
+  if (BeginFrameForcesDamage()) {
+    all_active_child_surfaces_ready_to_draw_ =
+        begin_frame_source_->AllObserversFinishedFrame();
+    ScheduleBeginFrameDeadline();
+  }
+}
+
+void DisplayScheduler::BeginFrameSourceSwapping(BeginFrameSource* new_source) {
+  DCHECK(new_source);
+  if (observing_begin_frame_source_) {
+    begin_frame_source_->GetTargetSource()->RemoveObserver(this);
+    new_source->AddObserver(this);
+  }
+}
+
 base::TimeTicks DisplayScheduler::DesiredBeginFrameDeadlineTime() {
   if (output_surface_lost_) {
     TRACE_EVENT_INSTANT0("cc", "Lost output surface", TRACE_EVENT_SCOPE_THREAD);
     return base::TimeTicks();
   }
 
   if (pending_swaps_ >= max_pending_swaps_) {
     TRACE_EVENT_INSTANT0("cc", "Swap throttled", TRACE_EVENT_SCOPE_THREAD);
     return current_begin_frame_args_.frame_time +
            current_begin_frame_args_.interval;
   }
 
-  if (!needs_draw_) {
+  // Allow an immediate deadline even if there's no damage and we know that
+  // no BeginFrameObservers are active.
+  if (!needs_draw_ &&
+      !(BeginFrameForcesDamage() && all_active_child_surfaces_ready_to_draw_)) {
     TRACE_EVENT_INSTANT0("cc", "No damage yet", TRACE_EVENT_SCOPE_THREAD);
     return current_begin_frame_args_.frame_time +
            current_begin_frame_args_.interval;
   }
 
   if (root_surface_resources_locked_) {
     TRACE_EVENT_INSTANT0("cc", "Root surface resources locked",
                          TRACE_EVENT_SCOPE_THREAD);
     return current_begin_frame_args_.frame_time +
            current_begin_frame_args_.interval;
@@ skipping 94 matching lines @@
     expect_damage_from_root_surface_ = false;
 
     StopObservingBeginFrames();
   }
 }
 
 void DisplayScheduler::OnBeginFrameDeadline() {
   TRACE_EVENT0("cc", "DisplayScheduler::OnBeginFrameDeadline");
 
   AttemptDrawAndSwap();
-  begin_frame_source_->DidFinishFrame(this, 0);
+  begin_frame_source_->GetTargetSource()->DidFinishFrame(this, 0);
 }
 
 void DisplayScheduler::DidSwapBuffers() {
   pending_swaps_++;
   TRACE_EVENT_ASYNC_BEGIN1("cc", "DisplayScheduler:pending_swaps", this,
                            "pending_frames", pending_swaps_);
 }
 
 void DisplayScheduler::DidReceiveSwapBuffersAck() {
   pending_swaps_--;
   TRACE_EVENT_ASYNC_END1("cc", "DisplayScheduler:pending_swaps", this,
                          "pending_frames", pending_swaps_);
   ScheduleBeginFrameDeadline();
 }
 
 }  // namespace cc