Roll Chrome into Mojo.

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"
 
 namespace cc {
 
 BeginFrameSource* SchedulerFrameSourcesConstructor::ConstructPrimaryFrameSource(
     Scheduler* scheduler) {
-  if (!scheduler->settings_.throttle_frame_production) {
+  if (scheduler->settings_.use_external_begin_frame_source) {
     TRACE_EVENT1("cc",
                  "Scheduler::Scheduler()",
                  "PrimaryFrameSource",
-                 "BackToBackBeginFrameSource");
-    DCHECK(!scheduler->primary_frame_source_internal_);
-    scheduler->primary_frame_source_internal_ =
-        BackToBackBeginFrameSource::Create(scheduler->task_runner_.get());
-    return scheduler->primary_frame_source_internal_.get();
-  } else if (scheduler->settings_.use_external_begin_frame_source) {
-    TRACE_EVENT1("cc",
-                 "Scheduler::Scheduler()",
-                 "PrimaryFrameSource",
                  "ExternalBeginFrameSource");
     DCHECK(scheduler->primary_frame_source_internal_)
         << "Need external BeginFrameSource";
     return scheduler->primary_frame_source_internal_.get();
   } else {
     TRACE_EVENT1("cc",
                  "Scheduler::Scheduler()",
                  "PrimaryFrameSource",
                  "SyntheticBeginFrameSource");
     scoped_ptr<SyntheticBeginFrameSource> synthetic_source =
@@ skipping 18 matching lines @@
                "BackgroundFrameSource",
                "SyntheticBeginFrameSource");
   DCHECK(!(scheduler->background_frame_source_internal_));
   scheduler->background_frame_source_internal_ =
       SyntheticBeginFrameSource::Create(
           scheduler->task_runner_.get(), scheduler->Now(),
           scheduler->settings_.background_frame_interval);
   return scheduler->background_frame_source_internal_.get();
 }
 
+BeginFrameSource*
+SchedulerFrameSourcesConstructor::ConstructUnthrottledFrameSource(
+    Scheduler* scheduler) {
+  TRACE_EVENT1("cc", "Scheduler::Scheduler()", "UnthrottledFrameSource",
+               "BackToBackBeginFrameSource");
+  DCHECK(!scheduler->unthrottled_frame_source_internal_);
+  scheduler->unthrottled_frame_source_internal_ =
+      BackToBackBeginFrameSource::Create(scheduler->task_runner_.get());
+  return scheduler->unthrottled_frame_source_internal_.get();
+}
+
 Scheduler::Scheduler(
     SchedulerClient* client,
     const SchedulerSettings& scheduler_settings,
     int layer_tree_host_id,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     base::PowerMonitor* power_monitor,
     scoped_ptr<BeginFrameSource> external_begin_frame_source,
     SchedulerFrameSourcesConstructor* frame_sources_constructor)
     : frame_source_(),
       primary_frame_source_(NULL),
       background_frame_source_(NULL),
       primary_frame_source_internal_(external_begin_frame_source.Pass()),
       background_frame_source_internal_(),
       vsync_observer_(NULL),
+      throttle_frame_production_(scheduler_settings.throttle_frame_production),
       settings_(scheduler_settings),
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
       power_monitor_(power_monitor),
-      begin_retro_frame_posted_(false),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false),
       inside_action_(SchedulerStateMachine::ACTION_NONE),
       weak_factory_(this) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                "Scheduler::Scheduler",
                "settings",
                settings_.AsValue());
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeeded());
@@ skipping 14 matching lines @@
   primary_frame_source_ =
       frame_sources_constructor->ConstructPrimaryFrameSource(this);
   frame_source_->AddSource(primary_frame_source_);
   primary_frame_source_->SetClientReady();
 
   // Background ticking frame source
   background_frame_source_ =
       frame_sources_constructor->ConstructBackgroundFrameSource(this);
   frame_source_->AddSource(background_frame_source_);
 
+  // Unthrottled frame source
+  unthrottled_frame_source_ =
+      frame_sources_constructor->ConstructUnthrottledFrameSource(this);
+  frame_source_->AddSource(unthrottled_frame_source_);
+
   SetupPowerMonitoring();
 }
 
 Scheduler::~Scheduler() {
   TeardownPowerMonitoring();
   if (frame_source_->NeedsBeginFrames())
     frame_source_->SetNeedsBeginFrames(false);
 }
 
 base::TimeTicks Scheduler::Now() const {
@@ skipping 39 matching lines @@
 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();
 }
 
-void Scheduler::SetVisible(bool visible) {
-  state_machine_.SetVisible(visible);
-  if (visible) {
-    frame_source_->SetActiveSource(primary_frame_source_);
+void Scheduler::UpdateActiveFrameSource() {
+  if (state_machine_.visible()) {
+    if (throttle_frame_production_) {
+      frame_source_->SetActiveSource(primary_frame_source_);
+    } else {
+      frame_source_->SetActiveSource(unthrottled_frame_source_);
+    }
   } else {
     frame_source_->SetActiveSource(background_frame_source_);
   }
   ProcessScheduledActions();
 }
 
+void Scheduler::SetVisible(bool visible) {
+  state_machine_.SetVisible(visible);
+  UpdateActiveFrameSource();
+}
+
 void Scheduler::SetCanDraw(bool can_draw) {
   state_machine_.SetCanDraw(can_draw);
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyReadyToActivate() {
   state_machine_.NotifyReadyToActivate();
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyReadyToDraw() {
   // Empty for now, until we take action based on the notification as part of
   // crbugs 352894, 383157, 421923.
 }
 
+void Scheduler::SetThrottleFrameProduction(bool throttle) {
+  throttle_frame_production_ = throttle;
+  UpdateActiveFrameSource();
+}
+
 void Scheduler::SetNeedsCommit() {
   state_machine_.SetNeedsCommit();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetNeedsRedraw() {
   state_machine_.SetNeedsRedraw();
   ProcessScheduledActions();
 }
 
@@ skipping 44 matching lines @@
   state_machine_.BeginMainFrameAborted(reason);
   ProcessScheduledActions();
 }
 
 void Scheduler::DidPrepareTiles() {
   state_machine_.DidPrepareTiles();
 }
 
 void Scheduler::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidLoseOutputSurface");
+  begin_retro_frame_args_.clear();
+  begin_retro_frame_task_.Cancel();
   state_machine_.DidLoseOutputSurface();
-  if (frame_source_->NeedsBeginFrames())
-    frame_source_->SetNeedsBeginFrames(false);
-  begin_retro_frame_args_.clear();
   ProcessScheduledActions();
 }
 
 void Scheduler::DidCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
   DCHECK(!frame_source_->NeedsBeginFrames());
   DCHECK(begin_impl_frame_deadline_task_.IsCancelled());
   state_machine_.DidCreateAndInitializeOutputSurface();
   ProcessScheduledActions();
 }
@@ skipping 16 matching lines @@
 }
 
 base::TimeTicks Scheduler::LastBeginImplFrameTime() {
   return begin_impl_frame_args_.frame_time;
 }
 
 void Scheduler::SetupNextBeginFrameIfNeeded() {
   if (!task_runner_.get())
     return;
 
-  bool needs_begin_frame = state_machine_.BeginFrameNeeded();
-
-  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 && !frame_source_->NeedsBeginFrames()) ||
-      // Only stop requesting BeginFrames after a deadline.
-      (!needs_begin_frame && frame_source_->NeedsBeginFrames() &&
-       at_end_of_deadline);
-
-  if (should_call_set_needs_begin_frame) {
-    frame_source_->SetNeedsBeginFrames(needs_begin_frame);
+  if (state_machine_.ShouldSetNeedsBeginFrames(
+          frame_source_->NeedsBeginFrames())) {
+    frame_source_->SetNeedsBeginFrames(state_machine_.BeginFrameNeeded());
   }
 
-  if (at_end_of_deadline) {
+  if (state_machine_.begin_impl_frame_state() ==
+      SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) {
     frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
   }
 
   PostBeginRetroFrameIfNeeded();
-  SetupPollingMechanisms(needs_begin_frame);
+  SetupPollingMechanisms();
 }
 
 // We may need to poll when we can't rely on BeginFrame to advance certain
 // state or to avoid deadlock.
-void Scheduler::SetupPollingMechanisms(bool needs_begin_frame) {
+void Scheduler::SetupPollingMechanisms() {
   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()
                                   ? begin_impl_frame_args_.interval
                                   : BeginFrameArgs::DefaultInterval();
       task_runner_->PostDelayedTask(
           FROM_HERE, poll_for_draw_triggers_task_.callback(), delay);
     }
   } else {
     poll_for_draw_triggers_task_.Cancel();
@@ skipping 59 matching lines @@
   }
 
   BeginFrameArgs adjusted_args(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_ ||
+        !begin_retro_frame_args_.empty() ||
+        !begin_retro_frame_task_.IsCancelled() ||
         !frame_source_->NeedsBeginFrames() ||
         (state_machine_.begin_impl_frame_state() !=
          SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   }
 
   if (should_defer_begin_frame) {
     begin_retro_frame_args_.push_back(adjusted_args);
     TRACE_EVENT_INSTANT0(
         "cc", "Scheduler::BeginFrame deferred", TRACE_EVENT_SCOPE_THREAD);
     // Queuing the frame counts as "using it", so we need to return true.
   } else {
     BeginImplFrame(adjusted_args);
   }
   return true;
 }
 
 void Scheduler::SetChildrenNeedBeginFrames(bool children_need_begin_frames) {
   DCHECK(settings_.forward_begin_frames_to_children);
   state_machine_.SetChildrenNeedBeginFrames(children_need_begin_frames);
   ProcessScheduledActions();
 }
 
 // BeginRetroFrame is called for BeginFrames that we've deferred because
 // the scheduler was in the middle of processing a previous BeginFrame.
 void Scheduler::BeginRetroFrame() {
   TRACE_EVENT0("cc", "Scheduler::BeginRetroFrame");
   DCHECK(!settings_.using_synchronous_renderer_compositor);
-  DCHECK(begin_retro_frame_posted_);
+  DCHECK(!begin_retro_frame_args_.empty());
+  DCHECK(!begin_retro_frame_task_.IsCancelled());
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
-  begin_retro_frame_posted_ = false;
 
-  // If there aren't any retroactive BeginFrames, then we've lost the
-  // OutputSurface and should abort.
-  if (begin_retro_frame_args_.empty())
-    return;
+  begin_retro_frame_task_.Cancel();
 
   // Discard expired BeginRetroFrames
   // Today, we should always end up with at most one un-expired BeginRetroFrame
   // because deadlines will not be greater than the next frame time. We don't
   // DCHECK though because some systems don't always have monotonic timestamps.
   // TODO(brianderson): In the future, long deadlines could result in us not
   // draining the queue if we don't catch up. If we consistently can't catch
   // up, our fallback should be to lower our frame rate.
   base::TimeTicks now = Now();
 
@@ skipping 26 matching lines @@
 // will check if there is a pending BeginRetroFrame to ensure we handle
 // BeginFrames in FIFO order.
 void Scheduler::PostBeginRetroFrameIfNeeded() {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                "Scheduler::PostBeginRetroFrameIfNeeded",
                "state",
                AsValue());
   if (!frame_source_->NeedsBeginFrames())
     return;
 
-  if (begin_retro_frame_args_.empty() || begin_retro_frame_posted_)
+  if (begin_retro_frame_args_.empty() || !begin_retro_frame_task_.IsCancelled())
     return;
 
   // begin_retro_frame_args_ should always be empty for the
   // synchronous compositor.
   DCHECK(!settings_.using_synchronous_renderer_compositor);
 
   if (state_machine_.begin_impl_frame_state() !=
       SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE)
     return;
 
-  begin_retro_frame_posted_ = true;
-  task_runner_->PostTask(FROM_HERE, begin_retro_frame_closure_);
+  begin_retro_frame_task_.Reset(begin_retro_frame_closure_);
+
+  task_runner_->PostTask(FROM_HERE, begin_retro_frame_task_.callback());
 }
 
 // BeginImplFrame starts a compositor frame that will wait up until a deadline
 // for a BeginMainFrame+activation to complete before it times out and draws
 // any asynchronous animation and scroll/pinch updates.
 void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
   bool main_thread_is_in_high_latency_mode =
       state_machine_.MainThreadIsInHighLatencyMode();
   TRACE_EVENT2("cc",
                "Scheduler::BeginImplFrame",
@@ skipping 214 matching lines @@
     state->EndDictionary();
   }
 
   state->BeginDictionary("scheduler_state");
   state->SetDouble("time_until_anticipated_draw_time_ms",
                    (AnticipatedDrawTime() - Now()).InMillisecondsF());
   state->SetDouble("estimated_parent_draw_time_ms",
                    estimated_parent_draw_time_.InMillisecondsF());
   state->SetBoolean("last_set_needs_begin_frame_",
                     frame_source_->NeedsBeginFrames());
-  state->SetBoolean("begin_retro_frame_posted_", begin_retro_frame_posted_);
   state->SetInteger("begin_retro_frame_args_", begin_retro_frame_args_.size());
+  state->SetBoolean("begin_retro_frame_task_",
+                    !begin_retro_frame_task_.IsCancelled());
   state->SetBoolean("begin_impl_frame_deadline_task_",
                     !begin_impl_frame_deadline_task_.IsCancelled());
   state->SetBoolean("poll_for_draw_triggers_task_",
                     !poll_for_draw_triggers_task_.IsCancelled());
   state->SetBoolean("advance_commit_state_task_",
                     !advance_commit_state_task_.IsCancelled());
   state->BeginDictionary("begin_impl_frame_args");
   begin_impl_frame_args_.AsValueInto(state);
   state->EndDictionary();
 
@@ skipping 31 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