cc: Avoid dynamic calls to base::Bind in 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/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 15 matching lines @@
       last_set_needs_begin_impl_frame_(false),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false),
       inside_action_(SchedulerStateMachine::ACTION_NONE),
       weak_factory_(this) {
   DCHECK(client_);
   DCHECK(!state_machine_.BeginImplFrameNeeded());
   if (settings_.main_frame_before_activation_enabled) {
     DCHECK(settings_.main_frame_before_draw_enabled);
   }
+
+  begin_impl_frame_deadline_closure_ = base::Bind(
+      &Scheduler::OnBeginImplFrameDeadline, weak_factory_.GetWeakPtr());
+  poll_for_draw_triggers_closure_ = base::Bind(
+      &Scheduler::PollForAnticipatedDrawTriggers, weak_factory_.GetWeakPtr());
+  advance_commit_state_closure_ = base::Bind(
+      &Scheduler::PollToAdvanceCommitState, weak_factory_.GetWeakPtr());
 }
 
 Scheduler::~Scheduler() {}
 
 void Scheduler::SetCanStart() {
   state_machine_.SetCanStart();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetVisible(bool visible) {
@@ skipping 70 matching lines @@
 void Scheduler::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidLoseOutputSurface");
   state_machine_.DidLoseOutputSurface();
   last_set_needs_begin_impl_frame_ = false;
   ProcessScheduledActions();
 }
 
 void Scheduler::DidCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
   DCHECK(!last_set_needs_begin_impl_frame_);
-  DCHECK(begin_impl_frame_deadline_closure_.IsCancelled());
+  DCHECK(begin_impl_frame_deadline_task_.IsCancelled());
   state_machine_.DidCreateAndInitializeOutputSurface();
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyBeginMainFrameStarted() {
   TRACE_EVENT0("cc", "Scheduler::NotifyBeginMainFrameStarted");
   state_machine_.NotifyBeginMainFrameStarted();
 }
 
 base::TimeTicks Scheduler::AnticipatedDrawTime() const {
@@ skipping 33 matching lines @@
     last_set_needs_begin_impl_frame_ = needs_begin_impl_frame;
   }
 
   bool needs_advance_commit_state_timer = false;
   // Setup PollForAnticipatedDrawTriggers if we need to monitor state but
   // aren't expecting any more BeginImplFrames. This should only be needed by
   // the synchronous compositor when BeginImplFrameNeeded is false.
   if (state_machine_.ShouldPollForAnticipatedDrawTriggers()) {
     DCHECK(!state_machine_.SupportsProactiveBeginImplFrame());
     DCHECK(!needs_begin_impl_frame);
-    if (poll_for_draw_triggers_closure_.IsCancelled()) {
-      poll_for_draw_triggers_closure_.Reset(
-          base::Bind(&Scheduler::PollForAnticipatedDrawTriggers,
-                     weak_factory_.GetWeakPtr()));
+    if (poll_for_draw_triggers_task_.IsCancelled()) {
+      poll_for_draw_triggers_task_.Reset(poll_for_draw_triggers_closure_);
       base::TimeDelta delay = last_begin_impl_frame_args_.IsValid()
                                   ? last_begin_impl_frame_args_.interval
                                   : BeginFrameArgs::DefaultInterval();
       impl_task_runner_->PostDelayedTask(
-          FROM_HERE, poll_for_draw_triggers_closure_.callback(), delay);
+          FROM_HERE, poll_for_draw_triggers_task_.callback(), delay);
     }
   } else {
-    poll_for_draw_triggers_closure_.Cancel();
+    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 BeginImplFrame 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 BeginImplFrame. 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_closure_.IsCancelled() &&
+    if (advance_commit_state_task_.IsCancelled() &&
         last_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_closure_.Reset(base::Bind(
-          &Scheduler::PollToAdvanceCommitState, weak_factory_.GetWeakPtr()));
+      advance_commit_state_task_.Reset(advance_commit_state_closure_);
       impl_task_runner_->PostDelayedTask(
           FROM_HERE,
-          advance_commit_state_closure_.callback(),
+          advance_commit_state_task_.callback(),
           last_begin_impl_frame_args_.interval * 2);
     }
   } else {
-    advance_commit_state_closure_.Cancel();
+    advance_commit_state_task_.Cancel();
   }
 }
 
 void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
   TRACE_EVENT0("cc", "Scheduler::BeginImplFrame");
   DCHECK(state_machine_.begin_impl_frame_state() ==
          SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   DCHECK(state_machine_.HasInitializedOutputSurface());
 
-  advance_commit_state_closure_.Cancel();
+  advance_commit_state_task_.Cancel();
 
   last_begin_impl_frame_args_ = args;
   last_begin_impl_frame_args_.deadline -= client_->DrawDurationEstimate();
 
   if (!state_machine_.smoothness_takes_priority() &&
       state_machine_.MainThreadIsInHighLatencyMode() &&
       CanCommitAndActivateBeforeDeadline()) {
     state_machine_.SetSkipNextBeginMainFrameToReduceLatency();
   }
 
@@ skipping 37 matching lines @@
 void Scheduler::ScheduleBeginImplFrameDeadline(base::TimeTicks deadline) {
   if (settings_.using_synchronous_renderer_compositor) {
     // The synchronous renderer compositor has to make its GL calls
     // within this call.
     // TODO(brianderson): Have the OutputSurface initiate the deadline tasks
     // so the sychronous renderer compositor can take advantage of splitting
     // up the BeginImplFrame and deadline as well.
     OnBeginImplFrameDeadline();
     return;
   }
-  begin_impl_frame_deadline_closure_.Cancel();
-  begin_impl_frame_deadline_closure_.Reset(
-      base::Bind(&Scheduler::OnBeginImplFrameDeadline,
-                 weak_factory_.GetWeakPtr()));
+  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();
   impl_task_runner_->PostDelayedTask(
-      FROM_HERE, begin_impl_frame_deadline_closure_.callback(), delta);
+      FROM_HERE, begin_impl_frame_deadline_task_.callback(), delta);
 }
 
 void Scheduler::OnBeginImplFrameDeadline() {
   TRACE_EVENT0("cc", "Scheduler::OnBeginImplFrameDeadline");
-  begin_impl_frame_deadline_closure_.Cancel();
+  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:
   // * Sending the BeginMainFrame will not occur after the deadline in
   //     order to wait for more user-input before starting the next commit.
   // * Creating a new OuputSurface will not occur during the deadline in
   //     order to allow the state machine to "settle" first.
   state_machine_.OnBeginImplFrameDeadline();
   ProcessScheduledActions();
   state_machine_.OnBeginImplFrameIdle();
   ProcessScheduledActions();
 
   client_->DidBeginImplFrameDeadline();
 }
 
 void Scheduler::PollForAnticipatedDrawTriggers() {
   TRACE_EVENT0("cc", "Scheduler::PollForAnticipatedDrawTriggers");
-  poll_for_draw_triggers_closure_.Cancel();
+  poll_for_draw_triggers_task_.Cancel();
   state_machine_.DidEnterPollForAnticipatedDrawTriggers();
   ProcessScheduledActions();
   state_machine_.DidLeavePollForAnticipatedDrawTriggers();
 }
 
 void Scheduler::PollToAdvanceCommitState() {
   TRACE_EVENT0("cc", "Scheduler::PollToAdvanceCommitState");
-  advance_commit_state_closure_.Cancel();
+  advance_commit_state_task_.Cancel();
   ProcessScheduledActions();
 }
 
 bool Scheduler::IsBeginMainFrameSent() const {
   return state_machine_.commit_state() ==
          SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT;
 }
 
 void Scheduler::DrawAndSwapIfPossible() {
   DrawSwapReadbackResult result =
@@ skipping 85 matching lines @@
 scoped_ptr<base::Value> Scheduler::StateAsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
   state->Set("state_machine", state_machine_.AsValue().release());
 
   scoped_ptr<base::DictionaryValue> scheduler_state(new base::DictionaryValue);
   scheduler_state->SetDouble(
       "time_until_anticipated_draw_time_ms",
       (AnticipatedDrawTime() - base::TimeTicks::Now()).InMillisecondsF());
   scheduler_state->SetBoolean("last_set_needs_begin_impl_frame_",
                               last_set_needs_begin_impl_frame_);
-  scheduler_state->SetBoolean(
-      "begin_impl_frame_deadline_closure_",
-      !begin_impl_frame_deadline_closure_.IsCancelled());
-  scheduler_state->SetBoolean("poll_for_draw_triggers_closure_",
-                              !poll_for_draw_triggers_closure_.IsCancelled());
-  scheduler_state->SetBoolean("advance_commit_state_closure_",
-                              !advance_commit_state_closure_.IsCancelled());
+  scheduler_state->SetBoolean("begin_impl_frame_deadline_task_",
+                              !begin_impl_frame_deadline_task_.IsCancelled());
+  scheduler_state->SetBoolean("poll_for_draw_triggers_task_",
+                              !poll_for_draw_triggers_task_.IsCancelled());
+  scheduler_state->SetBoolean("advance_commit_state_task_",
+                              !advance_commit_state_task_.IsCancelled());
   state->Set("scheduler_state", scheduler_state.release());
 
   scoped_ptr<base::DictionaryValue> client_state(new base::DictionaryValue);
   client_state->SetDouble("draw_duration_estimate_ms",
                           client_->DrawDurationEstimate().InMillisecondsF());
   client_state->SetDouble(
       "begin_main_frame_to_commit_duration_estimate_ms",
       client_->BeginMainFrameToCommitDurationEstimate().InMillisecondsF());
   client_state->SetDouble(
       "commit_to_activate_duration_estimate_ms",
@@ skipping 22 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