Unified BeginFrame scheduling

cc/scheduler/scheduler.cc

 // Copyright 2011 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/scheduler/scheduler.h"
 
 #include <algorithm>
+
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "ui/gfx/frame_time.h"
 
@@ skipping 54 matching lines @@
     base::TimeTicks frame_time) {
   base::TimeTicks deadline = time_source_->NextTickTime();
   return BeginFrameArgs::Create(
       frame_time, deadline, scheduler_->VSyncInterval());
 }
 
 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",
                "settings",
                settings_.AsValue());
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeeded());
   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_ =
       base::Bind(&Scheduler::BeginUnthrottledFrame, weak_factory_.GetWeakPtr());
   begin_impl_frame_deadline_closure_ = base::Bind(
       &Scheduler::OnBeginImplFrameDeadline, weak_factory_.GetWeakPtr());
   poll_for_draw_triggers_closure_ = base::Bind(
       &Scheduler::PollForAnticipatedDrawTriggers, weak_factory_.GetWeakPtr());
   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() {
   if (synthetic_begin_frame_source_) {
     synthetic_begin_frame_source_->SetNeedsBeginFrame(false,
                                                       &begin_retro_frame_args_);
   }
 }
 
 void Scheduler::SetupSyntheticBeginFrames() {
   DCHECK(!synthetic_begin_frame_source_);
   synthetic_begin_frame_source_.reset(
       new SyntheticBeginFrameSource(this, task_runner_.get()));
 }
 
 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())
+    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) {
   DCHECK_GE(draw_time.ToInternalValue(), 0);
   estimated_parent_draw_time_ = draw_time;
 }
 
 void Scheduler::SetCanStart() {
   state_machine_.SetCanStart();
   ProcessScheduledActions();
@@ skipping 77 matching lines @@
 }
 
 void Scheduler::DidManageTiles() {
   state_machine_.DidManageTiles();
 }
 
 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_);
   }
   begin_retro_frame_args_.clear();
   ProcessScheduledActions();
 }
 
 void Scheduler::DidCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
   DCHECK(!last_set_needs_begin_frame_);
@@ skipping 45 matching lines @@
       state_machine_.begin_impl_frame_state() ==
           SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE;
 
   bool should_call_set_needs_begin_frame =
       // Always request the BeginFrame immediately if it wasn't needed before.
       (needs_begin_frame && !last_set_needs_begin_frame_) ||
       // Only stop requesting BeginFrames after a deadline.
       (!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(
           needs_begin_frame, &begin_retro_frame_args_);
     }
     last_set_needs_begin_frame_ = needs_begin_frame;
   }
 
   PostBeginRetroFrameIfNeeded();
 }
@@ skipping 85 matching lines @@
 
 // BeginFrame is the mechanism that tells us that now is a good time to start
 // making a frame. Usually this means that user input for the frame is complete.
 // If the scheduler is busy, we queue the BeginFrame to be handled later as
 // a BeginRetroFrame.
 void Scheduler::BeginFrame(const BeginFrameArgs& args) {
   TRACE_EVENT1("cc", "Scheduler::BeginFrame", "args", args.AsValue());
   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;
   if (settings_.using_synchronous_renderer_compositor) {
     should_defer_begin_frame = false;
   } else {
     should_defer_begin_frame =
         !begin_retro_frame_args_.empty() || begin_retro_frame_posted_ ||
         !last_set_needs_begin_frame_ ||
         (state_machine_.begin_impl_frame_state() !=
@@ skipping 184 matching lines @@
   TRACE_EVENT0("cc", "Scheduler::PollToAdvanceCommitState");
   advance_commit_state_task_.Cancel();
   ProcessScheduledActions();
 }
 
 bool Scheduler::IsBeginMainFrameSent() const {
   return state_machine_.commit_state() ==
          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);
 }
 
 void Scheduler::ProcessScheduledActions() {
   // We do not allow ProcessScheduledActions to be recursive.
   // The top-level call will iteratively execute the next action for us anyway.
   if (inside_process_scheduled_actions_)
     return;
@@ skipping 130 matching lines @@
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT ||
           state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED);
 }
 
 }  // namespace cc