cc: Move scheduling logic out of OutputSurface

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/logging.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"
 
 namespace cc {
 
 Scheduler::Scheduler(
     SchedulerClient* client,
     const SchedulerSettings& scheduler_settings,
     int layer_tree_host_id,
-    const scoped_refptr<base::SequencedTaskRunner>& impl_task_runner)
+    const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner)
     : settings_(scheduler_settings),
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       impl_task_runner_(impl_task_runner),
+      vsync_interval_(BeginFrameArgs::DefaultInterval()),
       last_set_needs_begin_frame_(false),
       begin_retro_frame_posted_(false),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false),
       inside_action_(SchedulerStateMachine::ACTION_NONE),
       weak_factory_(this) {
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeeded());
   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_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) {
+    SetupSyntheticBeginFrames();
+  }
 }
 
 Scheduler::~Scheduler() {}

[Sami, 2014/04/08 13:46:01]

Should probably stop the time source here.

[brianderson, 2014/04/09 02:52:05]

The timesource cleans itself up, but it wouldn't hurt.

[brianderson, 2014/04/10 23:45:58]

Done.

 
+void Scheduler::SetupSyntheticBeginFrames() {
+  if (gfx::FrameTime::TimestampsAreHighRes()) {
+    time_source_for_synthetic_begin_frames_ =
+        DelayBasedTimeSourceHighRes::Create(vsync_interval_,
+                                            impl_task_runner_.get());
+  } else {
+    time_source_for_synthetic_begin_frames_ =
+        DelayBasedTimeSource::Create(vsync_interval_, impl_task_runner_.get());
+  }
+  time_source_for_synthetic_begin_frames_->SetClient(this);
+}
+
+void Scheduler::OnTimerTick() {
+  DCHECK(!settings_.begin_frame_scheduling_enabled);
+  BeginFrameArgs synthentic_begin_frame_args(CreateSyntheticBeginFrameArgs(
+      time_source_for_synthetic_begin_frames_->LastTickTime()));
+  BeginFrame(synthentic_begin_frame_args);
+}
+
+BeginFrameArgs Scheduler::CreateSyntheticBeginFrameArgs(
+    base::TimeTicks frame_time) {
+  base::TimeTicks deadline =
+      time_source_for_synthetic_begin_frames_->NextTickTime() -
+      estimated_parent_draw_time_;
+  return BeginFrameArgs::Create(frame_time, deadline, vsync_interval_);
+}
+
+void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
+                                      base::TimeDelta interval) {
+  vsync_interval_ = interval;
+  if (!settings_.begin_frame_scheduling_enabled)
+    time_source_for_synthetic_begin_frames_->SetTimebaseAndInterval(timebase,
+                                                                    interval);
+}
+
+void Scheduler::SetEstimatedParentDrawTime(base::TimeDelta draw_time) {
+  estimated_parent_draw_time_ = draw_time;
+}
+
 void Scheduler::SetCanStart() {
   state_machine_.SetCanStart();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetVisible(bool visible) {
   state_machine_.SetVisible(visible);
   ProcessScheduledActions();
 }
 
@@ skipping 29 matching lines @@
 void Scheduler::SetNeedsManageTiles() {
   DCHECK(!IsInsideAction(SchedulerStateMachine::ACTION_MANAGE_TILES));
   state_machine_.SetNeedsManageTiles();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetMaxSwapsPending(int max) {
   state_machine_.SetMaxSwapsPending(max);
 }
 
-void Scheduler::DidSwapBuffers() { state_machine_.DidSwapBuffers(); }
+void Scheduler::DidSwapBuffers() {
+  DCHECK(state_machine_.HasInitializedOutputSurface());
+  state_machine_.DidSwapBuffers();
+}
 
 void Scheduler::SetSwapUsedIncompleteTile(bool used_incomplete_tile) {
   state_machine_.SetSwapUsedIncompleteTile(used_incomplete_tile);
   ProcessScheduledActions();
 }
 
 void Scheduler::OnSwapBuffersComplete() {
   state_machine_.OnSwapBuffersComplete();

[Sami, 2014/04/08 13:46:01]

That DCHECK in Scheduler::DidSwapBuffers could go here too.

[brianderson, 2014/04/09 02:52:05]

Good idea.

[brianderson, 2014/04/10 23:45:58]

Done.

   ProcessScheduledActions();
 }
 
 void Scheduler::SetSmoothnessTakesPriority(bool smoothness_takes_priority) {
   state_machine_.SetSmoothnessTakesPriority(smoothness_takes_priority);
   ProcessScheduledActions();
 }
 
 void Scheduler::SetMainThreadNeedsLayerTextures() {
   state_machine_.SetMainThreadNeedsLayerTextures();
@@ skipping 49 matching lines @@
   return timebase + (begin_impl_frame_args_.interval * intervals);
 }
 
 base::TimeTicks Scheduler::LastBeginImplFrameTime() {
   return begin_impl_frame_args_.frame_time;
 }
 
 void Scheduler::SetupNextBeginFrameIfNeeded() {
   bool needs_begin_frame = state_machine_.BeginFrameNeeded();
 
+  if (settings_.throttle_frame_production) {
+    SetupNextBeginFrameWhenVSyncEnabled(needs_begin_frame);

[Sami, 2014/04/08 13:46:01]

bikeshed: s/VSync/Throttling/ to keep the terms a little more clearly defined.

[brianderson, 2014/04/09 02:52:05]

I was afraid of confusing vsync throttling with swap-ack throttling. Would it be
ok to s/VSync/VSyncThrottling/ instead?

[brianderson, 2014/04/10 23:45:58]

Done.

+  } else {
+    SetupNextBeginFrameWhenVSyncDisabled(needs_begin_frame);
+  }
+  SetupPollingMechanisms(needs_begin_frame);
+}
+
+// When we are throttling frame production, we request BeginFrames
+// from the OutputSurface.
+void Scheduler::SetupNextBeginFrameWhenVSyncEnabled(bool needs_begin_frame) {
   bool at_end_of_deadline =
       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_) ||
-      // We always need to explicitly request our next BeginFrame.
-      at_end_of_deadline;
+      // 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) {
-    client_->SetNeedsBeginFrame(needs_begin_frame);
+    if (settings_.begin_frame_scheduling_enabled) {
+      client_->SetNeedsBeginFrame(needs_begin_frame);
+    } else {
+      base::TimeTicks missed_tick_time =
+          time_source_for_synthetic_begin_frames_->SetActive(needs_begin_frame);
+      if (!missed_tick_time.is_null()) {
+        begin_retro_frame_args_.push_back(
+            CreateSyntheticBeginFrameArgs(missed_tick_time));
+      }
+    }
     last_set_needs_begin_frame_ = needs_begin_frame;
   }
 
-  // Handle retroactive BeginFrames.
   if (needs_begin_frame)
     PostBeginRetroFrameIfNeeded();
+}
 
+// When we aren't throttling frame production, we create our own
+// BeginImplFrames as soon as we go idle, using the BeginRetroFrame logic.
+void Scheduler::SetupNextBeginFrameWhenVSyncDisabled(bool needs_begin_frame) {
+  last_set_needs_begin_frame_ = needs_begin_frame;
+
+  if (!needs_begin_frame || begin_retro_frame_posted_)
+    return;
+
+  if (state_machine_.begin_impl_frame_state() !=
+          SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE &&
+      state_machine_.begin_impl_frame_state() !=
+          SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) {
+    return;
+  }
+
+  base::TimeTicks now = gfx::FrameTime::Now();
+  base::TimeDelta interval = vsync_interval_ > base::TimeDelta()
+                                 ? vsync_interval_
+                                 : BeginFrameArgs::DefaultInterval();
+
+  DCHECK(begin_retro_frame_args_.empty());
+  begin_retro_frame_args_.push_back(
+      BeginFrameArgs::Create(now, now + interval, interval));
+  PostBeginRetroFrame();
+}
+
+void Scheduler::SetupPollingMechanisms(bool needs_begin_frame) {
   bool needs_advance_commit_state_timer = false;
   // Setup PollForAnticipatedDrawTriggers if we need to monitor state but
   // aren't expecting any more BeginFrames. This should only be needed by
   // the synchronous compositor when BeginFrameNeeded is false.
   if (state_machine_.ShouldPollForAnticipatedDrawTriggers()) {
     DCHECK(!state_machine_.SupportsProactiveBeginFrame());
     DCHECK(!needs_begin_frame);
     if (poll_for_draw_triggers_task_.IsCancelled()) {
       poll_for_draw_triggers_task_.Reset(poll_for_draw_triggers_closure_);
       base::TimeDelta delay = begin_impl_frame_args_.IsValid()
@@ skipping 43 matching lines @@
 
   if (state_machine_.begin_impl_frame_state() !=
       SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE)
     return;
 
   begin_retro_frame_posted_ = true;
   impl_task_runner_->PostTask(FROM_HERE, begin_retro_frame_closure_);
 }
 
 void Scheduler::BeginFrame(const BeginFrameArgs& args) {
+  DCHECK(settings_.throttle_frame_production);
   if (settings_.using_synchronous_renderer_compositor ||
       (last_set_needs_begin_frame_ && begin_retro_frame_args_.empty() &&
        state_machine_.begin_impl_frame_state() ==
            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE)) {
     BeginImplFrame(args);
   } else {
     begin_retro_frame_args_.push_back(args);
     TRACE_EVENT_INSTANT0(
         "cc", "Scheduler::BeginFrame deferred", TRACE_EVENT_SCOPE_THREAD);
   }
 }
 
+void Scheduler::PostBeginRetroFrame() {
+  begin_retro_frame_posted_ = true;
+  impl_task_runner_->PostTask(FROM_HERE, begin_retro_frame_closure_);
+}
+
 void Scheduler::BeginRetroFrame() {
   TRACE_EVENT0("cc", "Scheduler::BeginRetroFrame");
   DCHECK(begin_retro_frame_posted_);
   DCHECK(!begin_retro_frame_args_.empty());
 
   // Discard expired BeginRetroFrames
-  base::TimeTicks now = gfx::FrameTime::Now();
-  base::TimeDelta draw_duration_estimate = client_->DrawDurationEstimate();
-  while (!begin_retro_frame_args_.empty() &&
-         now > AdjustedBeginImplFrameDeadline(begin_retro_frame_args_.front(),
-                                              draw_duration_estimate)) {
-    begin_retro_frame_args_.pop_front();
+  // Not if frame production isn't throttled though, since all frames will be

[Sami, 2014/04/08 13:46:01]

This is getting a little confusing. Should we perhaps have a separate deque for
synthetic BeginFrames or something like ::BeginSyntheticFrame()?

[brianderson, 2014/04/09 02:52:05]

This is for the unthrottled (vsync disabled) frames, which uses neither the
synthetic logic nor the BeginFrame logic. My thinking was that we are always
trying to catch up when vsync is disabled and using the retroactive logic kind
of makes sense in a way and it happens to work out well in the code. It is a
little confusing though, so I could create a separate mechanism for that.

[brianderson, 2014/04/10 23:45:58]

Added a BeginUnthrottledFrame with a separate closure. It also doesn't use the
retroactive logic anymore.

+  // BeginRetroFrames.
+  if (settings_.throttle_frame_production) {
+    base::TimeTicks now = gfx::FrameTime::Now();
+    base::TimeDelta draw_duration_estimate = client_->DrawDurationEstimate();
+    while (!begin_retro_frame_args_.empty() &&
+           now > AdjustedBeginImplFrameDeadline(begin_retro_frame_args_.front(),
+                                                draw_duration_estimate)) {
+      begin_retro_frame_args_.pop_front();
+    }
   }
 
   if (begin_retro_frame_args_.empty()) {
+    DCHECK(settings_.throttle_frame_production);
     TRACE_EVENT_INSTANT0(
         "cc", "Scheduler::BeginRetroFrames expired", TRACE_EVENT_SCOPE_THREAD);
   } else {
     BeginImplFrame(begin_retro_frame_args_.front());
     begin_retro_frame_args_.pop_front();
   }
 
   begin_retro_frame_posted_ = false;
 }
 
 void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
-  TRACE_EVENT0("cc", "Scheduler::BeginImplFrame");
   DCHECK(state_machine_.begin_impl_frame_state() ==
          SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   DCHECK(state_machine_.HasInitializedOutputSurface());
 
   advance_commit_state_task_.Cancel();
 
   base::TimeDelta draw_duration_estimate = client_->DrawDurationEstimate();
   begin_impl_frame_args_ = args;
   begin_impl_frame_args_.deadline -= draw_duration_estimate;
 
@@ skipping 238 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