Allow cc::Scheduler begin frame source to be changed

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 @@
     SchedulerClient* client,
     const SchedulerSettings& settings,
     int layer_tree_host_id,
     base::SingleThreadTaskRunner* task_runner,
     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),
-      begin_frame_source_(begin_frame_source),
+      begin_frame_source_(nullptr),
       observing_begin_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());
 
   begin_retro_frame_closure_ =
       base::Bind(&Scheduler::BeginRetroFrame, weak_factory_.GetWeakPtr());
   begin_impl_frame_deadline_closure_ = base::Bind(
       &Scheduler::OnBeginImplFrameDeadline, weak_factory_.GetWeakPtr());
 
-  begin_frame_source_->SetClientReady();
+  SetBeginFrameSource(begin_frame_source);
   ProcessScheduledActions();
 }
 
 Scheduler::~Scheduler() {
   if (observing_begin_frame_source_)
     begin_frame_source_->RemoveObserver(this);
 }
 
 base::TimeTicks Scheduler::Now() const {
   base::TimeTicks now = base::TimeTicks::Now();
@@ skipping 25 matching lines @@
   state_machine_.NotifyReadyToActivate();
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyReadyToDraw() {
   // Future work might still needed for crbug.com/352894.
   state_machine_.NotifyReadyToDraw();
   ProcessScheduledActions();
 }
 
+void Scheduler::SetBeginFrameSource(BeginFrameSource* source) {

[Sami, 2016/03/09 17:09:15]

Not sure how often this would actually be used, but is it worth adding a check
for trying to switch to the same |source| we already have? I think
Add/RemoveObserver might involve IPC in some cases.

[enne (OOO), 2016/03/09 19:46:10]

Yeah, I think something needs to change here, as the scheduler has no idea
whether or not a source has had that called on it before.  I'll put up a patch
to address that separately.

+  DCHECK(source);
+  if (begin_frame_source_ && observing_begin_frame_source_)
+    begin_frame_source_->RemoveObserver(this);
+  begin_frame_source_ = source;
+  if (observing_begin_frame_source_)
+    begin_frame_source_->AddObserver(this);
+  begin_frame_source_->SetClientReady();

[Sami, 2016/03/09 17:09:15]

One problem here is that some begin frame sources (e.g., 
CompositorExternalBeginFrameSource) don't like it if you call SetClientReady
multiple times. Maybe we should change the API contract to allow that. Or maybe
SetClientReady could be folded into AddObserver.

+}
+
 void Scheduler::SetNeedsBeginMainFrame() {
   state_machine_.SetNeedsBeginMainFrame();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetNeedsOneBeginImplFrame() {
   state_machine_.SetNeedsOneBeginImplFrame();
   ProcessScheduledActions();
 }
 
@@ skipping 611 matching lines @@
 
   state->BeginDictionary("state_machine");
   state_machine_.AsValueInto(state);
   state->EndDictionary();
 
   // Only trace frame sources when explicitly enabled - http://crbug.com/420607
   bool frame_tracing_enabled = false;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
       &frame_tracing_enabled);
-  if (frame_tracing_enabled) {
+  if (frame_tracing_enabled && begin_frame_source_) {
     state->BeginDictionary("begin_frame_source_");
     begin_frame_source_->AsValueInto(state);
     state->EndDictionary();
   }
 
   state->BeginDictionary("scheduler_state");
   state->SetBoolean("throttle_frame_production_",
                     settings_.throttle_frame_production);
   state->SetDouble("estimated_parent_draw_time_ms",
                    estimated_parent_draw_time_.InMillisecondsF());
@@ skipping 92 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