Remove runtime toggling of throttling frames

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/logging.h"
@@ skipping 46 matching lines @@
     scoped_ptr<CompositorTimingHistory> compositor_timing_history)
     : settings_(settings),
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
       external_frame_source_(external_frame_source),
       synthetic_frame_source_(std::move(synthetic_frame_source)),
       unthrottled_frame_source_(std::move(unthrottled_frame_source)),
       frame_source_(BeginFrameSourceMultiplexer::Create()),
       observing_frame_source_(false),
-      throttle_frame_production_(false),
       compositor_timing_history_(std::move(compositor_timing_history)),
       begin_impl_frame_deadline_mode_(
           SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_NONE),
       begin_impl_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
       state_machine_(settings),
       inside_process_scheduled_actions_(false),
       inside_action_(SchedulerStateMachine::ACTION_NONE),
       weak_factory_(this) {
   TRACE_EVENT1("cc", "Scheduler::Scheduler", "settings", settings_.AsValue());
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeeded());
   DCHECK(!settings_.use_external_begin_frame_source || external_frame_source_);
   DCHECK(settings_.use_external_begin_frame_source || synthetic_frame_source_);
   DCHECK(unthrottled_frame_source_);
 
   begin_retro_frame_closure_ =
       base::Bind(&Scheduler::BeginRetroFrame, weak_factory_.GetWeakPtr());
   begin_impl_frame_deadline_closure_ = base::Bind(
       &Scheduler::OnBeginImplFrameDeadline, weak_factory_.GetWeakPtr());
 
   frame_source_->AddSource(primary_frame_source());
   primary_frame_source()->SetClientReady();
 
   frame_source_->AddSource(unthrottled_frame_source_.get());
   unthrottled_frame_source_->SetClientReady();
 
-  SetThrottleFrameProduction(settings_.throttle_frame_production);
+  if (settings_.throttle_frame_production) {
+    frame_source_->SetActiveSource(primary_frame_source());
+  } else {
+    frame_source_->SetActiveSource(unthrottled_frame_source_.get());
+  }
+  ProcessScheduledActions();
 }
 
 Scheduler::~Scheduler() {
   if (observing_frame_source_)
     frame_source_->RemoveObserver(this);
   frame_source_->SetActiveSource(nullptr);
 }
 
 base::TimeTicks Scheduler::Now() const {
   base::TimeTicks now = base::TimeTicks::Now();
@@ skipping 40 matching lines @@
   state_machine_.NotifyReadyToActivate();
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyReadyToDraw() {
   // Future work might still needed for crbug.com/352894.
   state_machine_.NotifyReadyToDraw();
   ProcessScheduledActions();
 }
 
-void Scheduler::SetThrottleFrameProduction(bool throttle) {
-  throttle_frame_production_ = throttle;
-  if (throttle) {
-    frame_source_->SetActiveSource(primary_frame_source());
-  } else {
-    frame_source_->SetActiveSource(unthrottled_frame_source_.get());
-  }
-  ProcessScheduledActions();
-}
-
 void Scheduler::SetNeedsBeginMainFrame() {
   state_machine_.SetNeedsBeginMainFrame();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetNeedsOneBeginImplFrame() {
   state_machine_.SetNeedsOneBeginImplFrame();
   ProcessScheduledActions();
 }
 
@@ skipping 626 matching lines @@
       TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
       &frame_tracing_enabled);
   if (frame_tracing_enabled) {
     state->BeginDictionary("frame_source_");
     frame_source_->AsValueInto(state);
     state->EndDictionary();
   }
 
   state->BeginDictionary("scheduler_state");
   state->SetBoolean("external_frame_source_", !!external_frame_source_);
-  state->SetBoolean("throttle_frame_production_", throttle_frame_production_);
+  state->SetBoolean("throttle_frame_production_",
+                    settings_.throttle_frame_production);
   state->SetDouble("authoritative_vsync_interval_ms",
                    authoritative_vsync_interval_.InMillisecondsF());
   state->SetDouble(
       "last_vsync_timebase_ms",
       (last_vsync_timebase_ - base::TimeTicks()).InMillisecondsF());
   state->SetDouble("estimated_parent_draw_time_ms",
                    estimated_parent_draw_time_.InMillisecondsF());
   state->SetBoolean("observing_frame_source", observing_frame_source_);
   state->SetInteger("begin_retro_frame_args",
                     static_cast<int>(begin_retro_frame_args_.size()));
@@ skipping 41 matching lines @@
 }
 
 bool Scheduler::ShouldRecoverImplLatency(
     const BeginFrameArgs& args,
     bool can_activate_before_deadline) const {
   DCHECK(!settings_.using_synchronous_renderer_compositor);
 
   // Disable impl thread latency recovery when using the unthrottled
   // begin frame source since we will always get a BeginFrame before
   // the swap ack and our heuristics below will not work.
-  if (!throttle_frame_production_)
+  if (!settings_.throttle_frame_production)
     return false;
 
   // If we are swap throttled at the BeginFrame, that means the impl thread is
   // very likely in a high latency mode.
   bool impl_thread_is_likely_high_latency = state_machine_.SwapThrottled();
   if (!impl_thread_is_likely_high_latency)
     return false;
 
   // The deadline may be in the past if our draw time is too long.
   bool can_draw_before_deadline = args.frame_time < args.deadline;
@@ skipping 27 matching lines @@
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.begin_main_frame_state() ==
               SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT ||
           state_machine_.begin_main_frame_state() ==
               SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_STARTED);
 }
 
 }  // namespace cc