cc: Implement deadine scheduling disabled by default

cc/scheduler/scheduler.cc

Index: cc/scheduler/scheduler.cc
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index d3e7aa5de366d4764b47220334382b13b124fd12..fc1c0456ee2dc4cc6b575f81b4528550c2e4584b 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -4,6 +4,7 @@
 
 #include "cc/scheduler/scheduler.h"
 
+#include <algorithm>
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ -18,16 +19,15 @@ Scheduler::Scheduler(SchedulerClient* client,
       weak_factory_(this),
       last_set_needs_begin_frame_(false),
       has_pending_begin_frame_(false),
-      safe_to_expect_begin_frame_(false),
+      safe_to_expect_begin_frame_(
+          !scheduler_settings.use_begin_frame_workaround_for_crbug_249806),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false) {
   DCHECK(client_);
-  DCHECK(!state_machine_.BeginFrameNeededToDrawByImplThread());
+  DCHECK(!state_machine_.BeginFrameNeededByImplThread());
 }
 
-Scheduler::~Scheduler() {
-  client_->SetNeedsBeginFrameOnImplThread(false);
-}
+Scheduler::~Scheduler() {}
 
 void Scheduler::SetCanStart() {
   state_machine_.SetCanStart();
@@ -49,6 +49,12 @@ void Scheduler::NotifyReadyToActivate() {
   ProcessScheduledActions();
 }
 
+void Scheduler::ActivatePendingTree() {
+  client_->ScheduledActionActivatePendingTree();
+  if (state_machine_.ShouldTriggerBeginFrameDeadlineEarly())
+    PostBeginFrameDeadline(base::TimeTicks());
+}
+
 void Scheduler::SetNeedsCommit() {
   state_machine_.SetNeedsCommit();
   ProcessScheduledActions();
@@ -79,6 +85,9 @@ void Scheduler::FinishCommit() {
   TRACE_EVENT0("cc", "Scheduler::FinishCommit");
   state_machine_.FinishCommit();
   ProcessScheduledActions();
+
+  if (state_machine_.ShouldTriggerBeginFrameDeadlineEarly())
+    PostBeginFrameDeadline(base::TimeTicks());
 }
 
 void Scheduler::BeginFrameAbortedByMainThread(bool did_handle) {
@@ -89,6 +98,8 @@ void Scheduler::BeginFrameAbortedByMainThread(bool did_handle) {
 
 void Scheduler::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidLoseOutputSurface");
+  begin_frame_deadline_closure_.Cancel();
+  has_pending_begin_frame_ = false;
   state_machine_.DidLoseOutputSurface();
   ProcessScheduledActions();
 }
@@ -96,9 +107,11 @@ void Scheduler::DidLoseOutputSurface() {
 void Scheduler::DidCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
   state_machine_.DidCreateAndInitializeOutputSurface();
+  begin_frame_deadline_closure_.Cancel();
   has_pending_begin_frame_ = false;
   last_set_needs_begin_frame_ = false;
-  safe_to_expect_begin_frame_ = false;
+  safe_to_expect_begin_frame_ =
+      !settings_.use_begin_frame_workaround_for_crbug_249806;
   ProcessScheduledActions();
 }
 
@@ -109,12 +122,11 @@ base::TimeTicks Scheduler::AnticipatedDrawTime() {
       last_begin_frame_args_.interval <= base::TimeDelta())
     return base::TimeTicks();
 
-  // TODO(brianderson): Express this in terms of the deadline.
   base::TimeTicks now = base::TimeTicks::Now();
-  int64 intervals = 1 + ((now - last_begin_frame_args_.frame_time) /
-                         last_begin_frame_args_.interval);
-  return last_begin_frame_args_.frame_time +
-      (last_begin_frame_args_.interval * intervals);
+  base::TimeTicks timebase = std::max(last_begin_frame_args_.frame_time,
+                                      last_begin_frame_args_.deadline);
+  int64 intervals = 1 + ((now - timebase) / last_begin_frame_args_.interval);
+  return timebase + (last_begin_frame_args_.interval * intervals);
 }
 
 base::TimeTicks Scheduler::LastBeginFrameOnImplThreadTime() {
@@ -124,41 +136,37 @@ base::TimeTicks Scheduler::LastBeginFrameOnImplThreadTime() {
 void Scheduler::SetupNextBeginFrameIfNeeded() {
   bool needs_begin_frame_to_draw =
       state_machine_.BeginFrameNeededToDrawByImplThread();
-  // We want to avoid proactive begin frames with the synchronous compositor
-  // because every SetNeedsBeginFrame will force a redraw.
   bool proactive_begin_frame_wanted =
-      state_machine_.ProactiveBeginFrameWantedByImplThread() &&
-      !settings_.using_synchronous_renderer_compositor &&
-      settings_.throttle_frame_production;
-  bool needs_begin_frame = needs_begin_frame_to_draw ||
-                           proactive_begin_frame_wanted;
-  bool immediate_disables_needed =
-      settings_.using_synchronous_renderer_compositor;
+      state_machine_.ProactiveBeginFrameWantedByImplThread();
+
+  // We want to avoid proactive begin frames with the synchronous
+  // compositor because every SetNeedsBeginFrame will force a redraw.
+  bool needs_begin_frame =
+      needs_begin_frame_to_draw || proactive_begin_frame_wanted;
+
+  bool should_call_set_needs_begin_frame =
+      // The synchronous renderer compositor needs immediate enables/disables.
+      (settings_.using_synchronous_renderer_compositor &&
+       needs_begin_frame != last_set_needs_begin_frame_) ||
+      // Always request the BeginFrame immediately if it wasn't needed before.
+      (needs_begin_frame && !last_set_needs_begin_frame_) ||
+      // Only disable the BeginFrame after a BeginFrame where we didn't swap.
+      (!needs_begin_frame && last_set_needs_begin_frame_ &&
+       has_pending_begin_frame_ && !state_machine_.InsideBeginFrame()) ||

[enne (OOO), 2013/09/11 22:30:47]

has_pending_begin_frame is a funny way of saying that a swap didn't happen.

+      // We did not draw and swap this BeginFrame,
+      // so we need to explicitly request another BeginFrame.
+      (needs_begin_frame && has_pending_begin_frame_ &&
+       !state_machine_.InsideBeginFrame());
 
   if (needs_begin_frame_to_draw)
     safe_to_expect_begin_frame_ = true;
 
-  // Determine if we need BeginFrame notifications.
-  // If we do, always request the BeginFrame immediately.
-  // If not, only disable on the next BeginFrame to avoid unnecessary toggles.
-  // The synchronous renderer compositor requires immediate disables though.
-  if ((needs_begin_frame ||
-       state_machine_.inside_begin_frame() ||
-       immediate_disables_needed) &&
-      (needs_begin_frame != last_set_needs_begin_frame_)) {
+  if (should_call_set_needs_begin_frame) {
     has_pending_begin_frame_ = false;
     client_->SetNeedsBeginFrameOnImplThread(needs_begin_frame);
     if (safe_to_expect_begin_frame_)
       last_set_needs_begin_frame_ = needs_begin_frame;
   }
-
-  // Request another BeginFrame if we haven't drawn for now until we have
-  // deadlines implemented.
-  if (state_machine_.inside_begin_frame() && has_pending_begin_frame_) {
-    has_pending_begin_frame_ = false;
-    client_->SetNeedsBeginFrameOnImplThread(true);
-    return;
-  }
 }
 
 void Scheduler::BeginFrame(const BeginFrameArgs& args) {
@@ -167,9 +175,60 @@ void Scheduler::BeginFrame(const BeginFrameArgs& args) {
   has_pending_begin_frame_ = true;
   safe_to_expect_begin_frame_ = true;
   last_begin_frame_args_ = args;
-  state_machine_.DidEnterBeginFrame(args);
+  last_begin_frame_args_.deadline -= client_->DrawDurationEstimate();
+  state_machine_.OnBeginFrame(last_begin_frame_args_);
+  ProcessScheduledActions();
+  state_machine_.OnBeginFrameDeadlinePending();
+
+  if (settings_.using_synchronous_renderer_compositor) {
+    // The synchronous renderer compositor has to make its GL calls
+    // within this call to BeginFrame.
+    // TODO(brianderson): Have the OutputSurface initiate the deadline tasks
+    // so the sychronous renderer compoistor can take advantage of splitting
+    // up the BeginFrame and deadline as well.
+    OnBeginFrameDeadline();
+  } else if (!settings_.deadline_scheduling_enabled) {
+    // We emulate the old non-deadline scheduler here by posting the
+    // deadline task without any delay.
+    PostBeginFrameDeadline(base::TimeTicks());
+  } else if (state_machine_.ShouldTriggerBeginFrameDeadlineEarly()) {
+    // We are ready to draw a new active tree immediately.
+    PostBeginFrameDeadline(base::TimeTicks());
+  } else if (state_machine_.needs_redraw()) {
+    // We have an animation or fast input path on the impl thread that wants
+    // to draw, so don't wait too long for a new active tree.
+    PostBeginFrameDeadline(last_begin_frame_args_.deadline);
+  } else {
+    // The impl thread doesn't have anything it wants to draw and we are just
+    // waiting for a new active tree, so post the deadline for the next
+    // expected BeginFrame start.
+    // TODO(brianderson): Handle long deadlines (that are past the next frame's
+    // frame time) properly instead of using this hack.
+    PostBeginFrameDeadline(last_begin_frame_args_.frame_time +

[enne (OOO), 2013/09/11 22:30:47]

This case almost seems like you shouldn't have a deadline at all.  If there's no
need to draw, then why post a deadline at all?  Or, is this what this comment is
about?

[brianderson, 2013/09/12 00:12:34]

We may not have to draw yet, but if a new commit comes in to trigger a draw,
that draw will have to wait until the next BeginFrame if we don't post the
deadline here. By posting the deadline task for the next anticipated frame time
when the impl thread doesn't have anything it wants to draw, the impl thread
will always draw as soon as there is a new active tree from the main thread.

[enne (OOO), 2013/09/12 00:26:45]

Oh! Thanks for the explanation.

+                           last_begin_frame_args_.interval);
+  }
+}
+
+void Scheduler::PostBeginFrameDeadline(base::TimeTicks deadline) {
+  begin_frame_deadline_closure_.Cancel();
+  begin_frame_deadline_closure_.Reset(
+      base::Bind(&Scheduler::OnBeginFrameDeadline, weak_factory_.GetWeakPtr()));
+  client_->PostBeginFrameDeadline(begin_frame_deadline_closure_.callback(),
+                                  deadline);
+}
+
+void Scheduler::OnBeginFrameDeadline() {
+  TRACE_EVENT0("cc", "Scheduler::OnBeginFrameDeadline");
+  begin_frame_deadline_closure_.Cancel();
+  state_machine_.OnBeginFrameDeadline();
   ProcessScheduledActions();
-  state_machine_.DidLeaveBeginFrame();
+  // We only transition out of BEGIN_FRAME_STATE_INSIDE_DEADLINE when all
+  // actions that occur back-to-back in response to entering
+  // BEGIN_FRAME_STATE_INSIDE_DEADLINE have completed. This is important
+  // because sending the BeginFrame to the main thread will not occur if
+  // we transition to BEGIN_FRAME_STATE_IDLE too early.
+  state_machine_.OnBeginFrameIdle();
+  client_->DidBeginFrameDeadlineOnImplThread();
 }
 
 void Scheduler::DrawAndSwapIfPossible() {
@@ -221,7 +280,7 @@ void Scheduler::ProcessScheduledActions() {
         client_->ScheduledActionUpdateVisibleTiles();
         break;
       case SchedulerStateMachine::ACTION_ACTIVATE_PENDING_TREE:
-        client_->ScheduledActionActivatePendingTree();
+        ActivatePendingTree();
         break;
       case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE:
         DrawAndSwapIfPossible();