Hoist begin frame sources out of scheduler

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 13 matching lines @@
 // for message latency and kernel scheduling variability.
 const base::TimeDelta kDeadlineFudgeFactor =
     base::TimeDelta::FromMicroseconds(1000);
 }
 
 scoped_ptr<Scheduler> Scheduler::Create(
     SchedulerClient* client,
     const SchedulerSettings& settings,
     int layer_tree_host_id,
     base::SingleThreadTaskRunner* task_runner,
-    BeginFrameSource* external_frame_source,
+    BeginFrameSource* begin_frame_source,
     scoped_ptr<CompositorTimingHistory> compositor_timing_history) {
-  scoped_ptr<SyntheticBeginFrameSource> synthetic_frame_source;
-  if (!settings.use_external_begin_frame_source) {
-    synthetic_frame_source = SyntheticBeginFrameSource::Create(
-        task_runner, BeginFrameArgs::DefaultInterval());
-  }
-  scoped_ptr<BackToBackBeginFrameSource> unthrottled_frame_source =
-      BackToBackBeginFrameSource::Create(task_runner);
-  return make_scoped_ptr(new Scheduler(
-      client, settings, layer_tree_host_id, task_runner, external_frame_source,
-      std::move(synthetic_frame_source), std::move(unthrottled_frame_source),
-      std::move(compositor_timing_history)));
+  return make_scoped_ptr(new Scheduler(client, settings, layer_tree_host_id,
+                                       task_runner, begin_frame_source,
+                                       std::move(compositor_timing_history)));
 }
 
 Scheduler::Scheduler(
     SchedulerClient* client,
     const SchedulerSettings& settings,
     int layer_tree_host_id,
     base::SingleThreadTaskRunner* task_runner,
-    BeginFrameSource* external_frame_source,
-    scoped_ptr<SyntheticBeginFrameSource> synthetic_frame_source,
-    scoped_ptr<BackToBackBeginFrameSource> unthrottled_frame_source,
+    BeginFrameSource* begin_frame_source,
     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()),
+      frame_source_(begin_frame_source),
       observing_frame_source_(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();
-
-  if (settings_.throttle_frame_production) {
-    frame_source_->SetActiveSource(primary_frame_source());
-  } else {
-    frame_source_->SetActiveSource(unthrottled_frame_source_.get());
-  }
+  frame_source_->SetClientReady();
   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();
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.now"),
                "Scheduler::Now",
                "now",
                now);
   return now;
 }
 
-void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
-                                      base::TimeDelta interval) {
-  if (authoritative_vsync_interval_ != base::TimeDelta()) {
-    interval = authoritative_vsync_interval_;
-  } else if (interval == base::TimeDelta()) {
-    // TODO(brianderson): We should not be receiving 0 intervals.
-    interval = BeginFrameArgs::DefaultInterval();
-  }
-
-  last_vsync_timebase_ = timebase;
-
-  if (synthetic_frame_source_)
-    synthetic_frame_source_->OnUpdateVSyncParameters(timebase, interval);
-}
-
 void Scheduler::SetEstimatedParentDrawTime(base::TimeDelta draw_time) {
   DCHECK_GE(draw_time.ToInternalValue(), 0);
   estimated_parent_draw_time_ = draw_time;
 }
 
 void Scheduler::SetVisible(bool visible) {
   state_machine_.SetVisible(visible);
   UpdateCompositorTimingHistoryRecordingEnabled();
   ProcessScheduledActions();
 }
@@ skipping 212 matching lines @@
     BeginImplFrameWithDeadline(adjusted_args);
   }
   return true;
 }
 
 void Scheduler::SetChildrenNeedBeginFrames(bool children_need_begin_frames) {
   state_machine_.SetChildrenNeedBeginFrames(children_need_begin_frames);
   ProcessScheduledActions();
 }
 
-void Scheduler::SetAuthoritativeVSyncInterval(const base::TimeDelta& interval) {
-  authoritative_vsync_interval_ = interval;
-  if (synthetic_frame_source_) {
-    synthetic_frame_source_->OnUpdateVSyncParameters(last_vsync_timebase_,
-                                                     interval);
-  }
-}
-
 void Scheduler::SetVideoNeedsBeginFrames(bool video_needs_begin_frames) {
   state_machine_.SetVideoNeedsBeginFrames(video_needs_begin_frames);
   ProcessScheduledActions();
 }
 
 void Scheduler::OnDrawForOutputSurface(bool resourceless_software_draw) {
   DCHECK(settings_.using_synchronous_renderer_compositor);
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   DCHECK(!BeginImplFrameDeadlinePending());
@@ skipping 413 matching lines @@
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       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_",
                     settings_.throttle_frame_production);
-  state->SetDouble("authoritative_vsync_interval_ms",

[enne (OOO), 2016/03/03 23:06:14]

I'm not sure if anybody was using this info, but I'm not sure where it would go
now, so have just removed it.

[Sami, 2016/03/08 19:15:24]

I think it was here just for debugging, so no need to keep it around.

-                   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()));
   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->SetString("inside_action",
@@ skipping 84 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