Revert of Make SingleThreadProxy a SchedulerClient

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"
@@ skipping 61 matching lines @@
     base::TimeTicks frame_time) {
   base::TimeTicks deadline = time_source_->NextTickTime();
   return BeginFrameArgs::Create(
       frame_time, deadline, scheduler_->VSyncInterval());
 }
 
 Scheduler::Scheduler(
     SchedulerClient* client,
     const SchedulerSettings& scheduler_settings,
     int layer_tree_host_id,
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+    const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner)
     : settings_(scheduler_settings),
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
-      task_runner_(task_runner),
+      impl_task_runner_(impl_task_runner),
       vsync_interval_(BeginFrameArgs::DefaultInterval()),
       last_set_needs_begin_frame_(false),
       begin_unthrottled_frame_posted_(false),
       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",
@@ skipping 24 matching lines @@
 Scheduler::~Scheduler() {
   if (synthetic_begin_frame_source_) {
     synthetic_begin_frame_source_->SetNeedsBeginFrame(false,
                                                       &begin_retro_frame_args_);
   }
 }
 
 void Scheduler::SetupSyntheticBeginFrames() {
   DCHECK(!synthetic_begin_frame_source_);
   synthetic_begin_frame_source_.reset(
-      new SyntheticBeginFrameSource(this, task_runner_.get()));
+      new SyntheticBeginFrameSource(this, impl_task_runner_.get()));
 }
 
 void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
                                       base::TimeDelta interval) {
   // TODO(brianderson): We should not be receiving 0 intervals.
   if (interval == base::TimeDelta())
     interval = BeginFrameArgs::DefaultInterval();
   vsync_interval_ = interval;
   if (!settings_.begin_frame_scheduling_enabled)
     synthetic_begin_frame_source_->CommitVSyncParameters(timebase, interval);
@@ skipping 125 matching lines @@
                                       begin_impl_frame_args_.deadline);
   int64 intervals = 1 + ((now - timebase) / begin_impl_frame_args_.interval);
   return timebase + (begin_impl_frame_args_.interval * intervals);
 }
 
 base::TimeTicks Scheduler::LastBeginImplFrameTime() {
   return begin_impl_frame_args_.frame_time;
 }
 
 void Scheduler::SetupNextBeginFrameIfNeeded() {
-  if (!task_runner_)
-    return;
-
   bool needs_begin_frame = state_machine_.BeginFrameNeeded();
 
   if (settings_.throttle_frame_production) {
     SetupNextBeginFrameWhenVSyncThrottlingEnabled(needs_begin_frame);
   } else {
     SetupNextBeginFrameWhenVSyncThrottlingDisabled(needs_begin_frame);
   }
   SetupPollingMechanisms(needs_begin_frame);
 }
 
@@ skipping 34 matching lines @@
     return;
 
   if (state_machine_.begin_impl_frame_state() !=
           SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE &&
       state_machine_.begin_impl_frame_state() !=
           SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) {
     return;
   }
 
   begin_unthrottled_frame_posted_ = true;
-  task_runner_->PostTask(FROM_HERE, begin_unthrottled_frame_closure_);
+  impl_task_runner_->PostTask(FROM_HERE, begin_unthrottled_frame_closure_);
 }
 
 // BeginUnthrottledFrame is used when we aren't throttling frame production.
 // This will usually be because VSync is disabled.
 void Scheduler::BeginUnthrottledFrame() {
   DCHECK(!settings_.throttle_frame_production);
   DCHECK(begin_retro_frame_args_.empty());
 
   base::TimeTicks now = gfx::FrameTime::Now();
   base::TimeTicks deadline = now + vsync_interval_;
@@ skipping 13 matching lines @@
   // 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(
+      impl_task_runner_->PostDelayedTask(
           FROM_HERE, poll_for_draw_triggers_task_.callback(), delay);
     }
   } else {
     poll_for_draw_triggers_task_.Cancel();
 
     // At this point we'd prefer to advance through the commit flow by
     // drawing a frame, however it's possible that the frame rate controller
     // will not give us a BeginFrame until the commit completes.  See
     // crbug.com/317430 for an example of a swap ack being held on commit. Thus
     // we set a repeating timer to poll on ProcessScheduledActions until we
     // successfully reach BeginFrame. Synchronous compositor does not use
     // frame rate controller or have the circular wait in the bug.
     if (IsBeginMainFrameSentOrStarted() &&
         !settings_.using_synchronous_renderer_compositor) {
       needs_advance_commit_state_timer = true;
     }
   }
 
   if (needs_advance_commit_state_timer) {
     if (advance_commit_state_task_.IsCancelled() &&
         begin_impl_frame_args_.IsValid()) {
       // Since we'd rather get a BeginImplFrame by the normal mechanism, we
       // set the interval to twice the interval from the previous frame.
       advance_commit_state_task_.Reset(advance_commit_state_closure_);
-      task_runner_->PostDelayedTask(FROM_HERE,
-                                    advance_commit_state_task_.callback(),
-                                    begin_impl_frame_args_.interval * 2);
+      impl_task_runner_->PostDelayedTask(FROM_HERE,
+                                         advance_commit_state_task_.callback(),
+                                         begin_impl_frame_args_.interval * 2);
     }
   } else {
     advance_commit_state_task_.Cancel();
   }
 }
 
 // BeginFrame is the mechanism that tells us that now is a good time to start
 // making a frame. Usually this means that user input for the frame is complete.
 // If the scheduler is busy, we queue the BeginFrame to be handled later as
 // a BeginRetroFrame.
@@ skipping 81 matching lines @@
 
   // 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_);
+  impl_task_runner_->PostTask(FROM_HERE, begin_retro_frame_closure_);
 }
 
 // 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) {
   TRACE_EVENT1("cc", "Scheduler::BeginImplFrame", "args", args.AsValue());
-  DCHECK_EQ(state_machine_.begin_impl_frame_state(),
-            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
+  DCHECK(state_machine_.begin_impl_frame_state() ==
+         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   DCHECK(state_machine_.HasInitializedOutputSurface());
 
   advance_commit_state_task_.Cancel();
 
   base::TimeDelta draw_duration_estimate = client_->DrawDurationEstimate();
   begin_impl_frame_args_ = args;
   begin_impl_frame_args_.deadline -= draw_duration_estimate;
 
   if (!state_machine_.smoothness_takes_priority() &&
       state_machine_.MainThreadIsInHighLatencyMode() &&
@@ skipping 46 matching lines @@
     // up the BeginImplFrame and deadline as well.
     OnBeginImplFrameDeadline();
     return;
   }
   begin_impl_frame_deadline_task_.Cancel();
   begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
 
   base::TimeDelta delta = deadline - gfx::FrameTime::Now();
   if (delta <= base::TimeDelta())
     delta = base::TimeDelta();
-  task_runner_->PostDelayedTask(
+  impl_task_runner_->PostDelayedTask(
       FROM_HERE, begin_impl_frame_deadline_task_.callback(), delta);
 }
 
 void Scheduler::OnBeginImplFrameDeadline() {
   TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
   begin_impl_frame_deadline_task_.Cancel();
 
   // We split the deadline actions up into two phases so the state machine
   // has a chance to trigger actions that should occur durring and after
   // the deadline separately. For example:
@@ skipping 171 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