Chromium -> Mojo roll.

cc/scheduler/scheduler_state_machine.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_state_machine.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 #include "ui/gfx/frame_time.h"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
       output_surface_state_(OUTPUT_SURFACE_LOST),
       begin_impl_frame_state_(BEGIN_IMPL_FRAME_STATE_IDLE),
       commit_state_(COMMIT_STATE_IDLE),
       forced_redraw_state_(FORCED_REDRAW_STATE_IDLE),
       commit_count_(0),
       current_frame_number_(0),
       last_frame_number_animate_performed_(-1),
       last_frame_number_swap_performed_(-1),
       last_frame_number_swap_requested_(-1),
       last_frame_number_begin_main_frame_sent_(-1),
+      animate_funnel_(false),
+      perform_swap_funnel_(false),
+      request_swap_funnel_(false),
+      send_begin_main_frame_funnel_(false),
       prepare_tiles_funnel_(0),
       consecutive_checkerboard_animations_(0),
       max_pending_swaps_(1),
       pending_swaps_(0),
       needs_redraw_(false),
       needs_animate_(false),
       needs_prepare_tiles_(false),
       needs_commit_(false),
       inside_poll_for_anticipated_draw_triggers_(false),
       visible_(false),
       can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
       pending_tree_is_ready_for_activation_(false),
       active_tree_needs_first_draw_(false),
-      did_commit_after_animating_(false),
       did_create_and_initialize_first_output_surface_(false),
       impl_latency_takes_priority_(false),
       skip_next_begin_main_frame_to_reduce_latency_(false),
       skip_begin_main_frame_to_reduce_latency_(false),
       continuous_painting_(false),
       children_need_begin_frames_(false),
-      defer_commits_(false) {
+      defer_commits_(false),
+      last_commit_had_no_updates_(false) {
 }
 
 const char* SchedulerStateMachine::OutputSurfaceStateToString(
     OutputSurfaceState state) {
   switch (state) {
     case OUTPUT_SURFACE_ACTIVE:
       return "OUTPUT_SURFACE_ACTIVE";
     case OUTPUT_SURFACE_LOST:
       return "OUTPUT_SURFACE_LOST";
     case OUTPUT_SURFACE_CREATING:
@@ skipping 82 matching lines @@
       return "ACTION_PREPARE_TILES";
   }
   NOTREACHED();
   return "???";
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 SchedulerStateMachine::AsValue() const {
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
-  AsValueInto(state.get(), gfx::FrameTime::Now());
+  AsValueInto(state.get());
   return state;
 }
 
-void SchedulerStateMachine::AsValueInto(base::trace_event::TracedValue* state,
-                                        base::TimeTicks now) const {
+void SchedulerStateMachine::AsValueInto(
+    base::trace_event::TracedValue* state) const {
   state->BeginDictionary("major_state");
   state->SetString("next_action", ActionToString(NextAction()));
   state->SetString("begin_impl_frame_state",
                    BeginImplFrameStateToString(begin_impl_frame_state_));
   state->SetString("commit_state", CommitStateToString(commit_state_));
   state->SetString("output_surface_state_",
                    OutputSurfaceStateToString(output_surface_state_));
   state->SetString("forced_redraw_state",
                    ForcedRedrawOnTimeoutStateToString(forced_redraw_state_));
   state->EndDictionary();
 
-  state->BeginDictionary("major_timestamps_in_ms");
-  state->SetDouble("0_interval",
-                   begin_impl_frame_args_.interval.InMicroseconds() / 1000.0L);
-  state->SetDouble(
-      "1_now_to_deadline",
-      (begin_impl_frame_args_.deadline - now).InMicroseconds() / 1000.0L);
-  state->SetDouble(
-      "2_frame_time_to_now",
-      (now - begin_impl_frame_args_.frame_time).InMicroseconds() / 1000.0L);
-  state->SetDouble("3_frame_time_to_deadline",
-                   (begin_impl_frame_args_.deadline -
-                    begin_impl_frame_args_.frame_time).InMicroseconds() /
-                       1000.0L);
-  state->SetDouble("4_now",
-                   (now - base::TimeTicks()).InMicroseconds() / 1000.0L);
-  state->SetDouble(
-      "5_frame_time",
-      (begin_impl_frame_args_.frame_time - base::TimeTicks()).InMicroseconds() /
-          1000.0L);
-  state->SetDouble(
-      "6_deadline",
-      (begin_impl_frame_args_.deadline - base::TimeTicks()).InMicroseconds() /
-          1000.0L);
-  state->EndDictionary();
-
   state->BeginDictionary("minor_state");
   state->SetInteger("commit_count", commit_count_);
   state->SetInteger("current_frame_number", current_frame_number_);
-
   state->SetInteger("last_frame_number_animate_performed",
                     last_frame_number_animate_performed_);
   state->SetInteger("last_frame_number_swap_performed",
                     last_frame_number_swap_performed_);
   state->SetInteger("last_frame_number_swap_requested",
                     last_frame_number_swap_requested_);
   state->SetInteger("last_frame_number_begin_main_frame_sent",
                     last_frame_number_begin_main_frame_sent_);
-
-  state->SetInteger("prepare_tiles_funnel", prepare_tiles_funnel_);
+  state->SetBoolean("funnel: animate_funnel", animate_funnel_);
+  state->SetBoolean("funnel: perform_swap_funnel", perform_swap_funnel_);
+  state->SetBoolean("funnel: request_swap_funnel", request_swap_funnel_);
+  state->SetBoolean("funnel: send_begin_main_frame_funnel",
+                    send_begin_main_frame_funnel_);
+  state->SetInteger("funnel: prepare_tiles_funnel", prepare_tiles_funnel_);
   state->SetInteger("consecutive_checkerboard_animations",
                     consecutive_checkerboard_animations_);
   state->SetInteger("max_pending_swaps_", max_pending_swaps_);
   state->SetInteger("pending_swaps_", pending_swaps_);
   state->SetBoolean("needs_redraw", needs_redraw_);
   state->SetBoolean("needs_animate_", needs_animate_);
   state->SetBoolean("needs_prepare_tiles", needs_prepare_tiles_);
   state->SetBoolean("needs_commit", needs_commit_);
   state->SetBoolean("visible", visible_);
   state->SetBoolean("can_start", can_start_);
   state->SetBoolean("can_draw", can_draw_);
   state->SetBoolean("has_pending_tree", has_pending_tree_);
   state->SetBoolean("pending_tree_is_ready_for_activation",
                     pending_tree_is_ready_for_activation_);
   state->SetBoolean("active_tree_needs_first_draw",
                     active_tree_needs_first_draw_);
-  state->SetBoolean("did_commit_after_animating", did_commit_after_animating_);
   state->SetBoolean("did_create_and_initialize_first_output_surface",
                     did_create_and_initialize_first_output_surface_);
   state->SetBoolean("impl_latency_takes_priority",
                     impl_latency_takes_priority_);
   state->SetBoolean("main_thread_is_in_high_latency_mode",
                     MainThreadIsInHighLatencyMode());
   state->SetBoolean("skip_begin_main_frame_to_reduce_latency",
                     skip_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
                     skip_next_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("continuous_painting", continuous_painting_);
   state->SetBoolean("children_need_begin_frames", children_need_begin_frames_);
   state->SetBoolean("defer_commits", defer_commits_);
   state->EndDictionary();
 }
 
 void SchedulerStateMachine::AdvanceCurrentFrameNumber() {
   current_frame_number_++;
 
+  animate_funnel_ = false;
+  perform_swap_funnel_ = false;
+  request_swap_funnel_ = false;
+  send_begin_main_frame_funnel_ = false;
+
   // "Drain" the PrepareTiles funnel.
   if (prepare_tiles_funnel_ > 0)
     prepare_tiles_funnel_--;
 
   skip_begin_main_frame_to_reduce_latency_ =
       skip_next_begin_main_frame_to_reduce_latency_;
   skip_next_begin_main_frame_to_reduce_latency_ = false;
 }
 
-bool SchedulerStateMachine::HasAnimatedThisFrame() const {
-  return last_frame_number_animate_performed_ == current_frame_number_;
-}
-
-bool SchedulerStateMachine::HasSentBeginMainFrameThisFrame() const {
-  return current_frame_number_ ==
-         last_frame_number_begin_main_frame_sent_;
-}
-
-bool SchedulerStateMachine::HasSwappedThisFrame() const {
-  return current_frame_number_ == last_frame_number_swap_performed_;
-}
-
-bool SchedulerStateMachine::HasRequestedSwapThisFrame() const {
-  return current_frame_number_ == last_frame_number_swap_requested_;
-}
-
 bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const {
   // These are all the cases where we normally cannot or do not want to draw
   // but, if needs_redraw_ is true and we do not draw to make forward progress,
   // we might deadlock with the main thread.
   // This should be a superset of PendingActivationsShouldBeForced() since
   // activation of the pending tree is blocked by drawing of the active tree and
   // the main thread might be blocked on activation of the most recent commit.
   if (PendingActivationsShouldBeForced())
     return true;
 
@@ skipping 52 matching lines @@
 
 bool SchedulerStateMachine::ShouldDraw() const {
   // If we need to abort draws, we should do so ASAP since the draw could
   // be blocking other important actions (like output surface initialization),
   // from occuring. If we are waiting for the first draw, then perfom the
   // aborted draw to keep things moving. If we are not waiting for the first
   // draw however, we don't want to abort for no reason.
   if (PendingDrawsShouldBeAborted())
     return active_tree_needs_first_draw_;
 
+  // Do not draw too many times in a single frame. It's okay that we don't check
+  // this before checking for aborted draws because aborted draws do not request
+  // a swap.
+  if (request_swap_funnel_)
+    return false;
+
   // Don't draw if we are waiting on the first commit after a surface.
   if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE)
     return false;
 
-  // If a commit has occurred after the animate call, we need to call animate
-  // again before we should draw.
-  if (did_commit_after_animating_)
-    return false;
-
-  // After this line, we only want to send a swap request once per frame.
-  if (HasRequestedSwapThisFrame())
-    return false;
-
   // Do not queue too many swaps.
   if (pending_swaps_ >= max_pending_swaps_)
     return false;
 
   // Except for the cases above, do not draw outside of the BeginImplFrame
   // deadline.
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
     return false;
 
   // Only handle forced redraws due to timeouts on the regular deadline.
@@ skipping 16 matching lines @@
 
   // If we want to force activation, do so ASAP.
   if (PendingActivationsShouldBeForced())
     return true;
 
   // At this point, only activate if we are ready to activate.
   return pending_tree_is_ready_for_activation_;
 }
 
 bool SchedulerStateMachine::ShouldAnimate() const {
+  // Do not animate too many times in a single frame.
+  if (animate_funnel_)
+    return false;
+
   // Don't animate if we are waiting on the first commit after a surface.
   if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE)
     return false;
 
-  // If a commit occurred after our last call, we need to do animation again.
-  if (HasAnimatedThisFrame() && !did_commit_after_animating_)
-    return false;
-
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING &&
       begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
     return false;
 
   return needs_redraw_ || needs_animate_;
 }
 
 bool SchedulerStateMachine::CouldSendBeginMainFrame() const {
+  // Do not send begin main frame too many times in a single frame.
+  if (send_begin_main_frame_funnel_)
+    return false;
+
   if (!needs_commit_)
     return false;
 
   // We can not perform commits if we are not visible.
   if (!visible_)
     return false;
 
   // Do not make a new commits when it is deferred.
   if (defer_commits_)
     return false;
@@ skipping 23 matching lines @@
   // thread isn't consuming user input.
   if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_IDLE &&
       BeginFrameNeeded())
     return false;
 
   // We need a new commit for the forced redraw. This honors the
   // single commit per interval because the result will be swapped to screen.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT)
     return true;
 
-  // After this point, we only start a commit once per frame.
-  if (HasSentBeginMainFrameThisFrame())
-    return false;
-
   // We shouldn't normally accept commits if there isn't an OutputSurface.
   if (!HasInitializedOutputSurface())
     return false;
 
   // SwapAck throttle the BeginMainFrames unless we just swapped.
   // TODO(brianderson): Remove this restriction to improve throughput.
   bool just_swapped_in_deadline =
       begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
-      HasSwappedThisFrame();
+      perform_swap_funnel_;
   if (pending_swaps_ >= max_pending_swaps_ && !just_swapped_in_deadline)
     return false;
 
   if (skip_begin_main_frame_to_reduce_latency_)
     return false;
 
   return true;
 }
 
 bool SchedulerStateMachine::ShouldCommit() const {
@@ skipping 56 matching lines @@
 void SchedulerStateMachine::UpdateState(Action action) {
   switch (action) {
     case ACTION_NONE:
       return;
 
     case ACTION_ACTIVATE_SYNC_TREE:
       UpdateStateOnActivation();
       return;
 
     case ACTION_ANIMATE:
+      DCHECK(!animate_funnel_);
       last_frame_number_animate_performed_ = current_frame_number_;
+      animate_funnel_ = true;
       needs_animate_ = false;
-      did_commit_after_animating_ = false;
       // TODO(skyostil): Instead of assuming this, require the client to tell
       // us.
       SetNeedsRedraw();
       return;
 
     case ACTION_SEND_BEGIN_MAIN_FRAME:
       DCHECK(!has_pending_tree_ ||
              settings_.main_frame_before_activation_enabled);
       DCHECK(visible_);
+      DCHECK(!send_begin_main_frame_funnel_);
       commit_state_ = COMMIT_STATE_BEGIN_MAIN_FRAME_SENT;
       needs_commit_ = false;
+      send_begin_main_frame_funnel_ = true;
       last_frame_number_begin_main_frame_sent_ =
           current_frame_number_;
       return;
 
     case ACTION_COMMIT: {
       bool commit_has_no_updates = false;
       UpdateStateOnCommit(commit_has_no_updates);
       return;
     }
 
@@ skipping 24 matching lines @@
 
     case ACTION_PREPARE_TILES:
       UpdateStateOnPrepareTiles();
       return;
   }
 }
 
 void SchedulerStateMachine::UpdateStateOnCommit(bool commit_has_no_updates) {
   commit_count_++;
 
-  if (!commit_has_no_updates && HasAnimatedThisFrame())
-    did_commit_after_animating_ = true;
+  if (!commit_has_no_updates)
+    animate_funnel_ = false;
 
   if (commit_has_no_updates || settings_.main_frame_before_activation_enabled) {
     commit_state_ = COMMIT_STATE_IDLE;
   } else if (settings_.impl_side_painting) {
     commit_state_ = COMMIT_STATE_WAITING_FOR_ACTIVATION;
   } else {
     commit_state_ = settings_.main_thread_should_always_be_low_latency
                         ? COMMIT_STATE_WAITING_FOR_DRAW
                         : COMMIT_STATE_IDLE;
   }
@@ skipping 27 matching lines @@
        forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)) {
     needs_redraw_ = true;
     active_tree_needs_first_draw_ = true;
   }
 
   // This post-commit work is common to both completed and aborted commits.
   pending_tree_is_ready_for_activation_ = false;
 
   if (continuous_painting_)
     needs_commit_ = true;
+  last_commit_had_no_updates_ = commit_has_no_updates;
 }
 
 void SchedulerStateMachine::UpdateStateOnActivation() {
   if (commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION) {
     commit_state_ = settings_.main_thread_should_always_be_low_latency
                         ? COMMIT_STATE_WAITING_FOR_DRAW
                         : COMMIT_STATE_IDLE;
   }
 
   if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
@@ skipping 11 matching lines @@
 void SchedulerStateMachine::UpdateStateOnDraw(bool did_request_swap) {
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
     forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE;
 
   if (commit_state_ == COMMIT_STATE_WAITING_FOR_DRAW)
     commit_state_ = COMMIT_STATE_IDLE;
 
   needs_redraw_ = false;
   active_tree_needs_first_draw_ = false;
 
-  if (did_request_swap)
+  if (did_request_swap) {
+    DCHECK(!request_swap_funnel_);
+    request_swap_funnel_ = true;
     last_frame_number_swap_requested_ = current_frame_number_;
+  }
 }
 
 void SchedulerStateMachine::UpdateStateOnPrepareTiles() {
   needs_prepare_tiles_ = false;
 }
 
 void SchedulerStateMachine::SetSkipNextBeginMainFrameToReduceLatency() {
   TRACE_EVENT_INSTANT0("cc",
                        "Scheduler: SkipNextBeginMainFrameToReduceLatency",
                        TRACE_EVENT_SCOPE_THREAD);
@@ skipping 22 matching lines @@
   // Proactive BeginFrames are bad for the synchronous compositor because we
   // have to draw when we get the BeginFrame and could end up drawing many
   // duplicate frames if our new frame isn't ready in time.
   // To poll for state with the synchronous compositor without having to draw,
   // we rely on ShouldPollForAnticipatedDrawTriggers instead.
   // Synchronous compositor doesn't have a browser.
   DCHECK(!children_need_begin_frames_);
   return BeginFrameNeededToAnimateOrDraw();
 }
 
-bool SchedulerStateMachine::ShouldSetNeedsBeginFrames(
-    bool frame_source_needs_begin_frames) const {
-  bool needs_begin_frame = BeginFrameNeeded();
-
-  // Never call SetNeedsBeginFrames if the frame source has the right value.
-  if (needs_begin_frame == frame_source_needs_begin_frames)
-    return false;
-
-  // Always request the BeginFrame immediately if it's needed.
-  if (needs_begin_frame)
-    return true;
-
-  // Stop requesting BeginFrames after a deadline.
-  if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
-    return true;
-
-  // Stop requesting BeginFrames immediately when output surface is lost.
-  if (!HasInitializedOutputSurface())
-    return true;
-
-  return false;
-}
-
 bool SchedulerStateMachine::ShouldPollForAnticipatedDrawTriggers() const {
   // ShouldPollForAnticipatedDrawTriggers is what we use in place of
   // ProactiveBeginFrameWanted when we are using the synchronous
   // compositor.
   if (!SupportsProactiveBeginFrame()) {
     return !BeginFrameNeededToAnimateOrDraw() && ProactiveBeginFrameWanted();
   }
 
   // Non synchronous compositors should rely on
   // ProactiveBeginFrameWanted to poll for state instead.
@@ skipping 52 matching lines @@
   // Changing priorities may allow us to activate (given the new priorities),
   // which may result in a new frame.
   if (needs_prepare_tiles_)
     return true;
 
   // If we just sent a swap request, it's likely that we are going to produce
   // another frame soon. This helps avoid negative glitches in our
   // SetNeedsBeginFrame requests, which may propagate to the BeginImplFrame
   // provider and get sampled at an inopportune time, delaying the next
   // BeginImplFrame.
-  if (HasRequestedSwapThisFrame())
+  if (request_swap_funnel_)
+    return true;
+
+  // If the last commit was aborted because of early out (no updates), we should
+  // still want a begin frame in case there is a commit coming again.
+  if (last_commit_had_no_updates_)
     return true;
 
   return false;
 }
 
-void SchedulerStateMachine::OnBeginImplFrame(const BeginFrameArgs& args) {
+void SchedulerStateMachine::OnBeginImplFrame() {
   AdvanceCurrentFrameNumber();
-  begin_impl_frame_args_ = args;
   DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_IDLE)
       << AsValue()->ToString();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING;
+  last_commit_had_no_updates_ = false;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadlinePending() {
   DCHECK_EQ(begin_impl_frame_state_,
             BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING)
       << AsValue()->ToString();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadline() {
@@ skipping 63 matching lines @@
 }
 
 bool SchedulerStateMachine::MainThreadIsInHighLatencyMode() const {
   // If a commit is pending before the previous commit has been drawn, we
   // are definitely in a high latency mode.
   if (CommitPending() && (active_tree_needs_first_draw_ || has_pending_tree_))
     return true;
 
   // If we just sent a BeginMainFrame and haven't hit the deadline yet, the main
   // thread is in a low latency mode.
-  if (HasSentBeginMainFrameThisFrame() &&
+  if (send_begin_main_frame_funnel_ &&
       (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING ||
        begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME))
     return false;
 
   // If there's a commit in progress it must either be from the previous frame
   // or it started after the impl thread's deadline. In either case the main
   // thread is in high latency mode.
   if (CommitPending())
     return true;
 
   // Similarly, if there's a pending tree the main thread is in high latency
   // mode, because either
   //   it's from the previous frame
   // or
   //   we're currently drawing the active tree and the pending tree will thus
   //   only be drawn in the next frame.
   if (has_pending_tree_)
     return true;
 
   if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) {
     // Even if there's a new active tree to draw at the deadline or we've just
     // swapped it, it may have been triggered by a previous BeginImplFrame, in
     // which case the main thread is in a high latency mode.
-    return (active_tree_needs_first_draw_ || HasSwappedThisFrame()) &&
-           !HasSentBeginMainFrameThisFrame();
+    return (active_tree_needs_first_draw_ || perform_swap_funnel_) &&
+           !send_begin_main_frame_funnel_;
   }
 
   // If the active tree needs its first draw in any other state, we know the
   // main thread is in a high latency mode.
   return active_tree_needs_first_draw_;
 }
 
 void SchedulerStateMachine::DidEnterPollForAnticipatedDrawTriggers() {
   AdvanceCurrentFrameNumber();
   inside_poll_for_anticipated_draw_triggers_ = true;
@@ skipping 20 matching lines @@
   }
 }
 
 void SchedulerStateMachine::SetMaxSwapsPending(int max) {
   max_pending_swaps_ = max;
 }
 
 void SchedulerStateMachine::DidSwapBuffers() {
   pending_swaps_++;
   DCHECK_LE(pending_swaps_, max_pending_swaps_);
+  DCHECK(!perform_swap_funnel_);
 
+  perform_swap_funnel_ = true;
   last_frame_number_swap_performed_ = current_frame_number_;
 }
 
 void SchedulerStateMachine::DidSwapBuffersComplete() {
   DCHECK_GT(pending_swaps_, 0);
   pending_swaps_--;
 }
 
 void SchedulerStateMachine::SetImplLatencyTakesPriority(
     bool impl_latency_takes_priority) {
@@ skipping 133 matching lines @@
       static_cast<int>(begin_impl_frame_state_),
       static_cast<int>(commit_state_),
       has_pending_tree_ ? 'T' : 'F',
       pending_tree_is_ready_for_activation_ ? 'T' : 'F',
       active_tree_needs_first_draw_ ? 'T' : 'F',
       max_pending_swaps_,
       pending_swaps_);
 }
 
 }  // namespace cc