cc: Remove background ticking from LTHI.

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 31 matching lines @@
     DCHECK(!scheduler->vsync_observer_);
     scheduler->vsync_observer_ = synthetic_source.get();
 
     DCHECK(!scheduler->primary_frame_source_internal_);
     scheduler->primary_frame_source_internal_ = synthetic_source.Pass();
     return scheduler->primary_frame_source_internal_.get();
   }
 }
 
 BeginFrameSource*
-SchedulerFrameSourcesConstructor::ConstructBackgroundFrameSource(
-    Scheduler* scheduler) {
-  TRACE_EVENT1("cc",
-               "Scheduler::Scheduler()",
-               "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,
     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),
       authoritative_vsync_interval_(base::TimeDelta()),
       last_vsync_timebase_(base::TimeTicks()),
-      throttle_frame_production_(scheduler_settings.throttle_frame_production),
+      throttle_frame_production_(false),
       settings_(scheduler_settings),
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
       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",
@@ skipping 13 matching lines @@
 
   frame_source_ = BeginFrameSourceMultiplexer::Create();
   frame_source_->AddObserver(this);
 
   // Primary frame source
   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_);
+
+  SetThrottleFrameProduction(scheduler_settings.throttle_frame_production);
 }
 
 Scheduler::~Scheduler() {
   if (frame_source_->NeedsBeginFrames())
     frame_source_->SetNeedsBeginFrames(false);
 }
 
 base::TimeTicks Scheduler::Now() const {
   base::TimeTicks now = gfx::FrameTime::Now();
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.now"),
@@ skipping 21 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::UpdateActiveFrameSource() {

[brianderson, 2015/04/01 21:58:08]

Delete?

[mithro-old, 2015/04/02 01:03:59]

Done.

-  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_);

[jdduke (slow), 2015/04/01 19:21:21]

Why not set the active source to null if we're invisible? Or does that mess with
scheduling? I guess as long as we're not ticking or posting tasks at all when
we're invisible (regardless of the active source), that's enough.

[mithro-old, 2015/04/02 01:03:59]

The approach I took was to make scheduler understand that SetNeedsBeginFrame is
dependent on visibility. I feel this is a cleaner approach because the scheduler
has a better understanding of what is going on then.

-  }
-  ProcessScheduledActions();
 }
 
 void Scheduler::SetVisible(bool visible) {
   state_machine_.SetVisible(visible);
-  UpdateActiveFrameSource();
+  ProcessScheduledActions();
 }
 
 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();
+  if (throttle) {
+    frame_source_->SetActiveSource(primary_frame_source_);
+  } else {
+    frame_source_->SetActiveSource(unthrottled_frame_source_);
+  }
+  ProcessScheduledActions();
 }
 
 void Scheduler::SetNeedsCommit() {
   state_machine_.SetNeedsCommit();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetNeedsRedraw() {
   state_machine_.SetNeedsRedraw();
   ProcessScheduledActions();
@@ skipping 620 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