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..9cb5f26b3b3cdb26b771a320b8edf0e48a359865 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"
@@ -79,18 +80,21 @@ Scheduler::Scheduler(
     SchedulerClient* client,
     const SchedulerSettings& scheduler_settings,
     int layer_tree_host_id,
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    BeginFrameManager* begin_frame_manager)
     : settings_(scheduler_settings),
       client_(client),
       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),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false),
       inside_action_(SchedulerStateMachine::ACTION_NONE),
+      begin_frame_manager_(begin_frame_manager),
       weak_factory_(this) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                "Scheduler::Scheduler",
@@ -101,7 +105,10 @@ Scheduler::Scheduler(
   if (settings_.main_frame_before_activation_enabled) {
     DCHECK(settings_.main_frame_before_draw_enabled);
   }
-
+  if (settings_.begin_frame_publisher) {
+    DCHECK(begin_frame_manager_);
+    begin_frame_manager_->set_delegate(this);
+  }
   begin_retro_frame_closure_ =
       base::Bind(&Scheduler::BeginRetroFrame, weak_factory_.GetWeakPtr());
   begin_unthrottled_frame_closure_ =
@@ -113,9 +120,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() {
@@ -136,9 +142,18 @@ void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
   // 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())
+    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 +251,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 +317,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 +423,13 @@ 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()) {
+    // |arg.deadline| should be adjusted by subscribed Scheduler.
+    begin_frame_manager_->SendBeginFrameToChildren(args);
+  }
+
   adjusted_args.deadline -= EstimatedParentDrawTime();
 
   bool should_defer_begin_frame;
@@ -612,6 +634,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);