cc: Advance commit state with a CancelableClosure

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 184 matching lines @@
     // 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 !=
-      advance_commit_state_timer_.IsRunning()) {
-    if (needs_advance_commit_state_timer &&
+
+  if (needs_advance_commit_state_timer) {
+    if (advance_commit_state_closure_.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_timer_.Start(
+      advance_commit_state_closure_.Reset(base::Bind(
+          &Scheduler::PollToAdvanceCommitState, weak_factory_.GetWeakPtr()));
+      impl_task_runner_->PostDelayedTask(
           FROM_HERE,
-          last_begin_impl_frame_args_.interval * 2,
-          base::Bind(&Scheduler::ProcessScheduledActions,
-                     base::Unretained(this)));
-    } else {
-      advance_commit_state_timer_.Stop();
+          advance_commit_state_closure_.callback(),
+          last_begin_impl_frame_args_.interval * 2);
     }
+  } else {
+    advance_commit_state_closure_.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();
+
   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();
   }
 
   state_machine_.OnBeginImplFrame(last_begin_impl_frame_args_);
@@ skipping 75 matching lines @@
 }
 
 void Scheduler::PollForAnticipatedDrawTriggers() {
   TRACE_EVENT0("cc", "Scheduler::PollForAnticipatedDrawTriggers");
   poll_for_draw_triggers_closure_.Cancel();
   state_machine_.DidEnterPollForAnticipatedDrawTriggers();
   ProcessScheduledActions();
   state_machine_.DidLeavePollForAnticipatedDrawTriggers();
 }
 
+void Scheduler::PollToAdvanceCommitState() {
+  TRACE_EVENT0("cc", "Scheduler::PollToAdvanceCommitState");
+  advance_commit_state_closure_.Cancel();
+  ProcessScheduledActions();
+}
+
 bool Scheduler::IsBeginMainFrameSent() const {
   return state_machine_.commit_state() ==
          SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT;
 }
 
 void Scheduler::DrawAndSwapIfPossible() {
   DrawSwapReadbackResult result =
       client_->ScheduledActionDrawAndSwapIfPossible();
   state_machine_.DidDrawIfPossibleCompleted(result.draw_result);
 }
@@ skipping 87 matching lines @@
   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_timer_",
-                              advance_commit_state_timer_.IsRunning());
+  scheduler_state->SetBoolean("advance_commit_state_closure_",
+                              !advance_commit_state_closure_.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