cc: Make scheduling be driven by vsync for android webview.

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 89 matching lines @@
                "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());
-  poll_for_draw_triggers_closure_ = base::Bind(
-      &Scheduler::PollForAnticipatedDrawTriggers, weak_factory_.GetWeakPtr());
   advance_commit_state_closure_ = base::Bind(
       &Scheduler::PollToAdvanceCommitState, weak_factory_.GetWeakPtr());
 
   frame_source_ = BeginFrameSourceMultiplexer::Create();
   frame_source_->AddObserver(this);
 
   // Primary frame source
   primary_frame_source_ =
       frame_sources_constructor->ConstructPrimaryFrameSource(this);
   frame_source_->AddSource(primary_frame_source_);
@@ skipping 195 matching lines @@
       client_->SendBeginMainFrameNotExpectedSoon();
     }
   }
 
   PostBeginRetroFrameIfNeeded();
 }
 
 // We may need to poll when we can't rely on BeginFrame to advance certain
 // state or to avoid deadlock.
 void Scheduler::SetupPollingMechanisms() {
-  bool needs_advance_commit_state_timer = false;
-  // Setup PollForAnticipatedDrawTriggers if we need to monitor state but
-  // 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());
-    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(
-          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) {
+  // 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) {
     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);
     }
   } else {
@@ skipping 15 matching lines @@
     // TODO(simonhong): Once we have commitless update, we can get rid of
     // BeginMainFrameToCommitDurationEstimate() +
     // CommitToActivateDurationEstimate().
     adjusted_args_for_children.deadline -=
         (client_->BeginMainFrameToCommitDurationEstimate() +
          client_->CommitToActivateDurationEstimate() +
          client_->DrawDurationEstimate() + EstimatedParentDrawTime());
     client_->SendBeginFramesToChildren(adjusted_args_for_children);
   }
 
+  BeginFrameArgs adjusted_args(args);
+  adjusted_args.deadline -= EstimatedParentDrawTime();
+
+  if (settings_.using_synchronous_renderer_compositor) {
+    BeginImplFrame(adjusted_args);
+    return true;
+  }
+
   // We have just called SetNeedsBeginFrame(true) and the BeginFrameSource has
   // sent us the last BeginFrame we have missed. As we might not be able to
   // actually make rendering for this call, handle it like a "retro frame".
   // TODO(brainderson): Add a test for this functionality ASAP!
   if (args.type == BeginFrameArgs::MISSED) {
-    begin_retro_frame_args_.push_back(args);
+    begin_retro_frame_args_.push_back(adjusted_args);
     PostBeginRetroFrameIfNeeded();
     return true;
   }
 
-  BeginFrameArgs adjusted_args(args);
-  adjusted_args.deadline -= EstimatedParentDrawTime();
-
-  bool should_defer_begin_frame;
-  if (settings_.using_synchronous_renderer_compositor) {
-    should_defer_begin_frame = false;
-  } else {
-    should_defer_begin_frame =
-        !begin_retro_frame_args_.empty() ||
-        !begin_retro_frame_task_.IsCancelled() ||
-        !frame_source_->NeedsBeginFrames() ||
-        (state_machine_.begin_impl_frame_state() !=
-         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
-  }
+  bool should_defer_begin_frame =
+      !begin_retro_frame_args_.empty() ||
+      !begin_retro_frame_task_.IsCancelled() ||
+      !frame_source_->NeedsBeginFrames() ||
+      (state_machine_.begin_impl_frame_state() !=
+       SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
 
   if (should_defer_begin_frame) {
     begin_retro_frame_args_.push_back(adjusted_args);
     TRACE_EVENT_INSTANT0(
         "cc", "Scheduler::BeginFrame deferred", TRACE_EVENT_SCOPE_THREAD);
     // Queuing the frame counts as "using it", so we need to return true.
   } else {
     BeginImplFrame(adjusted_args);
   }
   return true;
 }
 
 void Scheduler::SetChildrenNeedBeginFrames(bool children_need_begin_frames) {
   state_machine_.SetChildrenNeedBeginFrames(children_need_begin_frames);
   ProcessScheduledActions();
 }
 
+void Scheduler::OnDrawForOutputSurface() {
+  DCHECK(settings_.using_synchronous_renderer_compositor);
+  DCHECK_EQ(state_machine_.begin_impl_frame_state(),
+            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
+  DCHECK(!BeginImplFrameDeadlinePending());
+
+  state_machine_.OnBeginImplFrameDeadline();
+  ProcessScheduledActions();
+
+  state_machine_.OnBeginImplFrameIdle();
+  ProcessScheduledActions();
+}
+
 // BeginRetroFrame is called for BeginFrames that we've deferred because
 // the scheduler was in the middle of processing a previous BeginFrame.
 void Scheduler::BeginRetroFrame() {
   TRACE_EVENT0("cc,benchmark", "Scheduler::BeginRetroFrame");
   DCHECK(!settings_.using_synchronous_renderer_compositor);
   DCHECK(!begin_retro_frame_args_.empty());
   DCHECK(!begin_retro_frame_task_.IsCancelled());
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
 
@@ skipping 70 matching lines @@
                "Scheduler::BeginImplFrame",
                "args",
                args.AsValue(),
                "main_thread_is_high_latency",
                main_thread_is_in_high_latency_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "MainThreadLatency",
                  main_thread_is_in_high_latency_mode);
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
+  DCHECK(!BeginImplFrameDeadlinePending());
   DCHECK(state_machine_.HasInitializedOutputSurface());
 
   advance_commit_state_task_.Cancel();
 
   begin_impl_frame_args_ = args;
   begin_impl_frame_args_.deadline -= client_->DrawDurationEstimate();
 
   if (!state_machine_.impl_latency_takes_priority() &&
       main_thread_is_in_high_latency_mode &&
       CanCommitAndActivateBeforeDeadline()) {
     state_machine_.SetSkipNextBeginMainFrameToReduceLatency();
   }
 
   state_machine_.OnBeginImplFrame();
   devtools_instrumentation::DidBeginFrame(layer_tree_host_id_);
   client_->WillBeginImplFrame(begin_impl_frame_args_);
 
   ProcessScheduledActions();
 
-  state_machine_.OnBeginImplFrameDeadlinePending();
-
   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 synchronous renderer compositor can take advantage of splitting
-    // up the BeginImplFrame and deadline as well.
-    OnBeginImplFrameDeadline();
+    // Synchronous compositor has no deadline.
+    state_machine_.OnBeginImplFrameIdle();
+    ProcessScheduledActions();
+    // Simulate the "finishing" of a frame here.
+    client_->DidBeginImplFrameDeadline();
+    frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
   } else {
-    ScheduleBeginImplFrameDeadline();
+    // The deadline will be scheduled in ProcessScheduledActions.
+    state_machine_.OnBeginImplFrameDeadlinePending();
+    ProcessScheduledActions();
   }
 }
 
 void Scheduler::ScheduleBeginImplFrameDeadline() {
-  // The synchronous compositor does not post a deadline task.
-  DCHECK(!settings_.using_synchronous_renderer_compositor);
-
   begin_impl_frame_deadline_task_.Cancel();
   begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
 
   begin_impl_frame_deadline_mode_ =
       state_machine_.CurrentBeginImplFrameDeadlineMode();
 
   base::TimeTicks deadline;
   switch (begin_impl_frame_deadline_mode_) {
+    case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_NONE:
+      // No deadline.
+      return;
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE:
       // We are ready to draw a new active tree immediately.
       // We don't use Now() here because it's somewhat expensive to call.
       deadline = base::TimeTicks();
       break;
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_REGULAR:
       // We are animating on the impl thread but we can wait for some time.
       deadline = begin_impl_frame_args_.deadline;
       break;
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE:
       // We are blocked for one reason or another and we should wait.
       // TODO(brianderson): Handle long deadlines (that are past the next
       // frame's frame time) properly instead of using this hack.
       deadline =
           begin_impl_frame_args_.frame_time + begin_impl_frame_args_.interval;
       break;
   }
 
-  TRACE_EVENT1(
-      "cc", "Scheduler::ScheduleBeginImplFrameDeadline", "deadline", deadline);
+  TRACE_EVENT2("cc", "Scheduler::ScheduleBeginImplFrameDeadline", "mode",
+               SchedulerStateMachine::BeginImplFrameDeadlineModeToString(
+                   begin_impl_frame_deadline_mode_),
+               "deadline", deadline);
 
-  base::TimeDelta delta = deadline - Now();
-  if (delta <= base::TimeDelta())
-    delta = base::TimeDelta();
+  base::TimeDelta delta = std::max(deadline - Now(), base::TimeDelta());
   task_runner_->PostDelayedTask(
       FROM_HERE, begin_impl_frame_deadline_task_.callback(), delta);
 }
 
-void Scheduler::RescheduleBeginImplFrameDeadlineIfNeeded() {
-  if (settings_.using_synchronous_renderer_compositor)
-    return;
-
+void Scheduler::ScheduleBeginImplFrameDeadlineIfNeeded() {
   if (state_machine_.begin_impl_frame_state() !=
       SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)
     return;
 
-  if (begin_impl_frame_deadline_mode_ !=
-      state_machine_.CurrentBeginImplFrameDeadlineMode())
-    ScheduleBeginImplFrameDeadline();
+  if (begin_impl_frame_deadline_mode_ ==
+          state_machine_.CurrentBeginImplFrameDeadlineMode() &&
+      BeginImplFrameDeadlinePending())
+    return;
+
+  ScheduleBeginImplFrameDeadline();
 }
 
 void Scheduler::OnBeginImplFrameDeadline() {
   TRACE_EVENT0("cc,benchmark", "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:
   // * Sending the BeginMainFrame will not occur after the deadline in
   //     order to wait for more user-input before starting the next commit.
@@ skipping 15 matching lines @@
   ProcessScheduledActions();
 
   // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is fixed.
   tracked_objects::ScopedTracker tracking_profile3(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "461509 Scheduler::OnBeginImplFrameDeadline3"));
   client_->DidBeginImplFrameDeadline();
   frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
 }
 
-void Scheduler::PollForAnticipatedDrawTriggers() {
-  TRACE_EVENT0("cc", "Scheduler::PollForAnticipatedDrawTriggers");
-  poll_for_draw_triggers_task_.Cancel();
-  state_machine_.DidEnterPollForAnticipatedDrawTriggers();
-  ProcessScheduledActions();
-  state_machine_.DidLeavePollForAnticipatedDrawTriggers();
-}
 
 void Scheduler::PollToAdvanceCommitState() {
   TRACE_EVENT0("cc", "Scheduler::PollToAdvanceCommitState");
   advance_commit_state_task_.Cancel();
   ProcessScheduledActions();
 }
 
 void Scheduler::DrawAndSwapIfPossible() {
   DrawResult result = client_->ScheduledActionDrawAndSwapIfPossible();
   state_machine_.DidDrawIfPossibleCompleted(result);
 }
 
 void Scheduler::SetDeferCommits(bool defer_commits) {
   TRACE_EVENT1("cc", "Scheduler::SetDeferCommits",
                 "defer_commits",
                 defer_commits);
   state_machine_.SetDeferCommits(defer_commits);
   ProcessScheduledActions();
 }
 
 void Scheduler::ProcessScheduledActions() {
   // We do not allow ProcessScheduledActions to be recursive.
   // The top-level call will iteratively execute the next action for us anyway.
   if (inside_process_scheduled_actions_)
     return;
 
-  base::AutoReset<bool> mark_inside(&inside_process_scheduled_actions_, true);
+  {  // Separate scope for mark_inside.
+    base::AutoReset<bool> mark_inside(&inside_process_scheduled_actions_, true);
 
-  SchedulerStateMachine::Action action;
-  do {
-    // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is fixed.
-    tracked_objects::ScopedTracker tracking_profile1(
-        FROM_HERE_WITH_EXPLICIT_FUNCTION(
-            "461509 Scheduler::ProcessScheduledActions1"));
-    action = state_machine_.NextAction();
-    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
-                 "SchedulerStateMachine",
-                 "state",
-                 AsValue());
-    VLOG(2) << "Scheduler::ProcessScheduledActions: "
-            << SchedulerStateMachine::ActionToString(action) << " "
-            << state_machine_.GetStatesForDebugging();
-    state_machine_.UpdateState(action);
-    base::AutoReset<SchedulerStateMachine::Action>
-        mark_inside_action(&inside_action_, action);
-    switch (action) {
-      case SchedulerStateMachine::ACTION_NONE:
-        break;
-      case SchedulerStateMachine::ACTION_ANIMATE: {
-        // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
-        // fixed.
-        tracked_objects::ScopedTracker tracking_profile2(
-            FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                "461509 Scheduler::ProcessScheduledActions2"));
-        client_->ScheduledActionAnimate();
-        break;
+    SchedulerStateMachine::Action action;
+    do {
+      // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+      // fixed.
+      tracked_objects::ScopedTracker tracking_profile1(
+          FROM_HERE_WITH_EXPLICIT_FUNCTION(
+              "461509 Scheduler::ProcessScheduledActions1"));
+      action = state_machine_.NextAction();
+      TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
+                   "SchedulerStateMachine", "state", AsValue());
+      VLOG(2) << "Scheduler::ProcessScheduledActions: "
+              << SchedulerStateMachine::ActionToString(action) << " "
+              << state_machine_.GetStatesForDebugging();
+      state_machine_.UpdateState(action);
+      base::AutoReset<SchedulerStateMachine::Action> mark_inside_action(
+          &inside_action_, action);
+      switch (action) {
+        case SchedulerStateMachine::ACTION_NONE:
+          break;
+        case SchedulerStateMachine::ACTION_ANIMATE: {
+          // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+          // fixed.
+          tracked_objects::ScopedTracker tracking_profile2(
+              FROM_HERE_WITH_EXPLICIT_FUNCTION(
+                  "461509 Scheduler::ProcessScheduledActions2"));
+          client_->ScheduledActionAnimate();
+          break;
+        }
+        case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME: {
+          // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+          // fixed.
+          tracked_objects::ScopedTracker tracking_profile3(
+              FROM_HERE_WITH_EXPLICIT_FUNCTION(
+                  "461509 Scheduler::ProcessScheduledActions3"));
+          client_->ScheduledActionSendBeginMainFrame();
+          break;
+        }
+        case SchedulerStateMachine::ACTION_COMMIT: {
+          // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+          // fixed.
+          tracked_objects::ScopedTracker tracking_profile4(
+              FROM_HERE_WITH_EXPLICIT_FUNCTION(
+                  "461509 Scheduler::ProcessScheduledActions4"));
+          client_->ScheduledActionCommit();
+          break;
+        }
+        case SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE: {
+          // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+          // fixed.
+          tracked_objects::ScopedTracker tracking_profile5(
+              FROM_HERE_WITH_EXPLICIT_FUNCTION(
+                  "461509 Scheduler::ProcessScheduledActions5"));
+          client_->ScheduledActionActivateSyncTree();
+          break;
+        }
+        case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE: {
+          // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+          // fixed.
+          tracked_objects::ScopedTracker tracking_profile6(
+              FROM_HERE_WITH_EXPLICIT_FUNCTION(
+                  "461509 Scheduler::ProcessScheduledActions6"));
+          DrawAndSwapIfPossible();
+          break;
+        }
+        case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED: {
+          // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+          // fixed.
+          tracked_objects::ScopedTracker tracking_profile7(
+              FROM_HERE_WITH_EXPLICIT_FUNCTION(
+                  "461509 Scheduler::ProcessScheduledActions7"));
+          client_->ScheduledActionDrawAndSwapForced();
+          break;
+        }
+        case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT:
+          // No action is actually performed, but this allows the state machine
+          // to advance out of it's waiting to draw state without actually
+          // drawing.
+          break;
+        case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION: {
+          // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+          // fixed.
+          tracked_objects::ScopedTracker tracking_profile8(
+              FROM_HERE_WITH_EXPLICIT_FUNCTION(
+                  "461509 Scheduler::ProcessScheduledActions8"));
+          client_->ScheduledActionBeginOutputSurfaceCreation();
+          break;
+        }
+        case SchedulerStateMachine::ACTION_PREPARE_TILES: {
+          // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+          // fixed.
+          tracked_objects::ScopedTracker tracking_profile9(
+              FROM_HERE_WITH_EXPLICIT_FUNCTION(
+                  "461509 Scheduler::ProcessScheduledActions9"));
+          client_->ScheduledActionPrepareTiles();
+          break;
+        }
+        case SchedulerStateMachine::ACTION_INVALIDATE_OUTPUT_SURFACE: {
+          // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
+          // fixed.
+          tracked_objects::ScopedTracker tracking_profile10(
+              FROM_HERE_WITH_EXPLICIT_FUNCTION(
+                  "461509 Scheduler::ProcessScheduledActions10"));
+          client_->ScheduledActionInvalidateOutputSurface();
+          break;
+        }
       }
-      case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME: {
-        // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
-        // fixed.
-        tracked_objects::ScopedTracker tracking_profile3(
-            FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                "461509 Scheduler::ProcessScheduledActions3"));
-        client_->ScheduledActionSendBeginMainFrame();
-        break;
-      }
-      case SchedulerStateMachine::ACTION_COMMIT: {
-        // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
-        // fixed.
-        tracked_objects::ScopedTracker tracking_profile4(
-            FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                "461509 Scheduler::ProcessScheduledActions4"));
-        client_->ScheduledActionCommit();
-        break;
-      }
-      case SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE: {
-        // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
-        // fixed.
-        tracked_objects::ScopedTracker tracking_profile5(
-            FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                "461509 Scheduler::ProcessScheduledActions5"));
-        client_->ScheduledActionActivateSyncTree();
-        break;
-      }
-      case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE: {
-        // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
-        // fixed.
-        tracked_objects::ScopedTracker tracking_profile6(
-            FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                "461509 Scheduler::ProcessScheduledActions6"));
-        DrawAndSwapIfPossible();
-        break;
-      }
-      case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED: {
-        // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
-        // fixed.
-        tracked_objects::ScopedTracker tracking_profile7(
-            FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                "461509 Scheduler::ProcessScheduledActions7"));
-        client_->ScheduledActionDrawAndSwapForced();
-        break;
-      }
-      case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT:
-        // No action is actually performed, but this allows the state machine to
-        // advance out of its waiting to draw state without actually drawing.
-        break;
-      case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION: {
-        // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
-        // fixed.
-        tracked_objects::ScopedTracker tracking_profile8(
-            FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                "461509 Scheduler::ProcessScheduledActions8"));
-        client_->ScheduledActionBeginOutputSurfaceCreation();
-        break;
-      }
-      case SchedulerStateMachine::ACTION_PREPARE_TILES: {
-        // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is
-        // fixed.
-        tracked_objects::ScopedTracker tracking_profile9(
-            FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                "461509 Scheduler::ProcessScheduledActions9"));
-        client_->ScheduledActionPrepareTiles();
-        break;
-      }
-    }
-  } while (action != SchedulerStateMachine::ACTION_NONE);
-
-  // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is fixed.
-  tracked_objects::ScopedTracker tracking_profile10(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "461509 Scheduler::ProcessScheduledActions10"));
-
-  SetupPollingMechanisms();
-
-  client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
+    } while (action != SchedulerStateMachine::ACTION_NONE);
+  }  // Separate scope for mark_inside.
 
   // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is fixed.
   tracked_objects::ScopedTracker tracking_profile11(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "461509 Scheduler::ProcessScheduledActions11"));
+  SetupPollingMechanisms();
 
-  RescheduleBeginImplFrameDeadlineIfNeeded();
+  // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is fixed.
+  tracked_objects::ScopedTracker tracking_profile12(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "461509 Scheduler::ProcessScheduledActions12"));
+  client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
 
+  // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is fixed.
+  tracked_objects::ScopedTracker tracking_profile13(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "461509 Scheduler::ProcessScheduledActions13"));
+  ScheduleBeginImplFrameDeadlineIfNeeded();
+
+  // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is fixed.
+  tracked_objects::ScopedTracker tracking_profile14(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "461509 Scheduler::ProcessScheduledActions14"));
   SetupNextBeginFrameIfNeeded();
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat> Scheduler::AsValue()
     const {
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
   AsValueInto(state.get());
   return state;
 }
@@ skipping 19 matching lines @@
                    (AnticipatedDrawTime() - Now()).InMillisecondsF());
   state->SetDouble("estimated_parent_draw_time_ms",
                    estimated_parent_draw_time_.InMillisecondsF());
   state->SetBoolean("last_set_needs_begin_frame_",
                     frame_source_->NeedsBeginFrames());
   state->SetInteger("begin_retro_frame_args_", 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->SetBoolean("poll_for_draw_triggers_task_",
-                    !poll_for_draw_triggers_task_.IsCancelled());
   state->SetBoolean("advance_commit_state_task_",
                     !advance_commit_state_task_.IsCancelled());
   state->BeginDictionary("begin_impl_frame_args");
   begin_impl_frame_args_.AsValueInto(state);
   state->EndDictionary();
 
   base::TimeTicks now = Now();
   base::TimeTicks frame_time = begin_impl_frame_args_.frame_time;
   base::TimeTicks deadline = begin_impl_frame_args_.deadline;
   base::TimeDelta interval = begin_impl_frame_args_.interval;
@@ skipping 44 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