Unified BeginFrame scheduling

cc/scheduler/scheduler.cc

Index: cc/scheduler/scheduler.cc
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index a20bfd2b3b0e2c6eece49c94fcfd66258bc5f5f3..e49383ccdcf68dcfd63a9cd83aa8b43709c06300 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -5,6 +5,7 @@
 #include "cc/scheduler/scheduler.h"
 
 #include <algorithm>
+
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
@@ -85,6 +86,7 @@ Scheduler::Scheduler(
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
       vsync_interval_(BeginFrameArgs::DefaultInterval()),
+      authoritative_vsync_interval_(base::TimeDelta()),
       last_set_needs_begin_frame_(false),
       begin_unthrottled_frame_posted_(false),
       begin_retro_frame_posted_(false),
@@ -101,7 +103,6 @@ Scheduler::Scheduler(
   if (settings_.main_frame_before_activation_enabled) {
     DCHECK(settings_.main_frame_before_draw_enabled);
   }
-
   begin_retro_frame_closure_ =
       base::Bind(&Scheduler::BeginRetroFrame, weak_factory_.GetWeakPtr());
   begin_unthrottled_frame_closure_ =
@@ -113,9 +114,8 @@ Scheduler::Scheduler(
   advance_commit_state_closure_ = base::Bind(
       &Scheduler::PollToAdvanceCommitState, weak_factory_.GetWeakPtr());
 
-  if (!settings_.begin_frame_scheduling_enabled) {
+  if (!settings_.begin_frame_receiver)
     SetupSyntheticBeginFrames();
-  }
 }
 
 Scheduler::~Scheduler() {
@@ -133,12 +133,21 @@ void Scheduler::SetupSyntheticBeginFrames() {
 
 void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
                                       base::TimeDelta interval) {
-  // TODO(brianderson): We should not be receiving 0 intervals.
-  if (interval == base::TimeDelta())
-    interval = BeginFrameArgs::DefaultInterval();
-  vsync_interval_ = interval;
-  if (!settings_.begin_frame_scheduling_enabled)
-    synthetic_begin_frame_source_->CommitVSyncParameters(timebase, interval);
+  if (authoritative_vsync_interval_ == base::TimeDelta()) {

[brianderson, 2014/09/04 18:45:46]

nit: I was imagining a form that doesn't require nested ifs:

if (authoritative_vsync_interval_ != base::TimeDelta()) {
  vsync_interval_ = authoritative_vsync_interval;
} else if (interval == base::TimeDelta()) {
  vsync_interval_ = BeginFrameArgs::DefaultInterval();
} else {
  vsync_interval_ = interval_;
}

+    // TODO(brianderson): We should not be receiving 0 intervals.
+    if (interval == base::TimeDelta())
+      interval = BeginFrameArgs::DefaultInterval();
+    vsync_interval_ = interval;
+  } else {
+    vsync_interval_ = authoritative_vsync_interval_;
+  }
+
+  last_timebase_ = timebase;
+
+  if (!settings_.begin_frame_receiver) {
+    synthetic_begin_frame_source_->CommitVSyncParameters(timebase,
+                                                         vsync_interval_);
+  }
 }
 
 void Scheduler::SetEstimatedParentDrawTime(base::TimeDelta draw_time) {
@@ -236,7 +245,7 @@ void Scheduler::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidLoseOutputSurface");
   state_machine_.DidLoseOutputSurface();
   last_set_needs_begin_frame_ = false;
-  if (!settings_.begin_frame_scheduling_enabled) {
+  if (!settings_.begin_frame_receiver) {
     synthetic_begin_frame_source_->SetNeedsBeginFrame(false,
                                                       &begin_retro_frame_args_);
   }
@@ -302,7 +311,7 @@ void Scheduler::SetupNextBeginFrameWhenVSyncThrottlingEnabled(
       (!needs_begin_frame && last_set_needs_begin_frame_ && at_end_of_deadline);
 
   if (should_call_set_needs_begin_frame) {
-    if (settings_.begin_frame_scheduling_enabled) {
+    if (settings_.begin_frame_receiver) {
       client_->SetNeedsBeginFrame(needs_begin_frame);
     } else {
       synthetic_begin_frame_source_->SetNeedsBeginFrame(
@@ -408,6 +417,21 @@ void Scheduler::BeginFrame(const BeginFrameArgs& args) {
   DCHECK(settings_.throttle_frame_production);
 
   BeginFrameArgs adjusted_args(args);
+
+  if (settings_.begin_frame_publisher &&
+      state_machine_.children_need_begin_frames()) {
+    // Adjust a dealine for child schedulers.
+    // TODO(simonhong): Once we have commitless update, we can get rid of
+    // BeginMainFrameToCommitDurationEstimate() +
+    // CommitToActivateDurationEstimate().
+    adjusted_args.deadline -=
+        (client_->BeginMainFrameToCommitDurationEstimate() +
+         client_->CommitToActivateDurationEstimate() +
+         client_->DrawDurationEstimate() +
+         EstimatedParentDrawTime());
+    client_->SendBeginFrameToChildren(args);

[brianderson, 2014/09/04 18:45:46]

You need to send the adjusted_args rather than the args now.

+  }
+
   adjusted_args.deadline -= EstimatedParentDrawTime();

[brianderson, 2014/09/04 18:45:46]

We'll want two different adjusted_args: one for the children and one for the
Browser.

 
   bool should_defer_begin_frame;
@@ -612,6 +636,23 @@ bool Scheduler::IsBeginMainFrameSent() const {
          SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT;
 }
 
+void Scheduler::SetChildrenNeedBeginFrames(bool need_begin_frame) {
+  DCHECK(settings_.begin_frame_publisher);
+
+  state_machine_.SetChildrenNeedBeginFrames(need_begin_frame);
+  ProcessScheduledActions();
+}
+
+void Scheduler::SetAuthoritativeVSyncInterval(base::TimeDelta interval) {
+  authoritative_vsync_interval_ = interval;
+  vsync_interval_ = interval;
+
+  if (!settings_.begin_frame_receiver) {
+    synthetic_begin_frame_source_->CommitVSyncParameters(last_timebase_,
+                                                         interval);
+  }
+}
+
 void Scheduler::DrawAndSwapIfPossible() {
   DrawResult result = client_->ScheduledActionDrawAndSwapIfPossible();
   state_machine_.DidDrawIfPossibleCompleted(result);