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

cc/scheduler/scheduler.cc

Index: cc/scheduler/scheduler.cc
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index 4224ba07d0b7d3ecc05ce41d8dce238e98ad741f..662493e1ecc64ab844d3e697e48d3dca44d03c59 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -107,8 +107,6 @@ Scheduler::Scheduler(
       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());
 
@@ -324,37 +322,15 @@ void Scheduler::SetupNextBeginFrameIfNeeded() {
 // 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

[mithro-old, 2015/03/23 12:47:09]

Is the stuff in crbug.com/317430 the only reason keeping this
SetupPollingMechanisms method alive?

[sunnyps, 2015/03/23 22:53:19]

I don't know for sure but I imagine so.

+  // 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
@@ -390,30 +366,30 @@ bool Scheduler::OnBeginFrameMixInDelegate(const BeginFrameArgs& args) {
     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);

[mithro-old, 2015/03/23 12:47:09]

Changing this too adjusted_args seems like an unrelated change?

[sunnyps, 2015/03/23 22:53:19]

Done. I moved this to another CL: https://codereview.chromium.org/1025373002

     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);
@@ -431,6 +407,19 @@ void Scheduler::SetChildrenNeedBeginFrames(bool children_need_begin_frames) {
   ProcessScheduledActions();
 }
 
+void Scheduler::OnDrawForOutputSurface() {

[mithro-old, 2015/03/23 12:47:09]

This "hack" for forcing the state_machine_ like this feels dangerous but I can't
really think of a better solution.

[sunnyps, 2015/03/23 22:53:19]

I don't intend for this to be a hack for long. After this CL lands I intend to
rename any functions/variables in the state machine and scheduler client to
remove any mention of the deadline and replace those with "draw phase" or
similar e.g. SchedulerStateMachine::OnBeginImplFrameDeadline will become
OnBeginImplFrameDraw (or OnDraw).

IMO the deadline is really a platform-specific implementation detail of the
scheduler and "inside the deadline" should not be a synonym for "inside draw".

[mithro-old, 2015/03/24 05:43:45]

Excellent, I think that will be great to do!

+  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() {
@@ -521,6 +510,7 @@ void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
                  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();
@@ -540,24 +530,21 @@ void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
 
   ProcessScheduledActions();
 
-  state_machine_.OnBeginImplFrameDeadlinePending();
-
   if (settings_.using_synchronous_renderer_compositor) {

[mithro-old, 2015/03/23 12:47:09]

Should we be switching on begin_impl_frame_deadline_mode here?

[sunnyps, 2015/03/23 22:53:19]

That won't work because the deadline mode is NONE outside of the deadline
pending state and we don't enter the deadline pending state here. Also, I think
it's better to make it clear that we are switching because of the synchronous
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();

[mithro-old, 2015/03/23 12:47:09]

This feels very similar to the OnBeginImplFrameDeadline method below.

[sunnyps, 2015/03/23 22:53:19]

Done. There are some differences, notably that we don't enter the deadline state
here. I have factored this out into Scheduler::FinishImplFrame.

+    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_);
 
@@ -566,6 +553,9 @@ void Scheduler::ScheduleBeginImplFrameDeadline() {
 
   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.
@@ -584,27 +574,27 @@ void Scheduler::ScheduleBeginImplFrameDeadline() {
       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() {

[mithro-old, 2015/03/23 12:47:08]

Does it make sense to split up this in some way so we don't have to duplicate
the state_machine_.OnBeginImplFrame calls?

[sunnyps, 2015/03/23 22:53:19]

Done. Factored the common stuff out into a FinishImplFrame function.

@@ -640,13 +630,6 @@ void Scheduler::OnBeginImplFrameDeadline() {
   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");
@@ -673,123 +656,140 @@ void Scheduler::ProcessScheduledActions() {
   if (inside_process_scheduled_actions_)
     return;
 
-  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;
-      }
-      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;
+  {  // 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"));

[mithro-old, 2015/03/23 12:47:09]

Is changing these FROM_HERE_WITH_EXPLICIT_FUNCTION values cause things to be
collated in a weird way?

Really these should have been named Scheduler::ProcessScheduledActions::Animate
or something....

[sunnyps, 2015/03/23 22:53:19]

Yeah, I agree with that. I think robliao@ is removing these in another CL any
way.

[mithro-old, 2015/03/24 05:43:45]

Just want to make sure you don't break robliao@'s stat collection before he
removes it.

+          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_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);
+    } 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_profile10(
+  tracked_objects::ScopedTracker tracking_profile11(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "461509 Scheduler::ProcessScheduledActions10"));
-
+          "461509 Scheduler::ProcessScheduledActions11"));
   SetupPollingMechanisms();
 
+  // 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_profile11(
+  tracked_objects::ScopedTracker tracking_profile13(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "461509 Scheduler::ProcessScheduledActions11"));
-
-  RescheduleBeginImplFrameDeadlineIfNeeded();
+          "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();
 }
 
@@ -829,8 +829,6 @@ void Scheduler::AsValueInto(base::trace_event::TracedValue* state) const {
                     !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");