Fork cc::OutputSurface into cc::CompositorFrameSink.

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"
 
 namespace cc {
 
 namespace {
 // Surfaces and CompositorTimingHistory don't support more than 1 pending swap.
 const int kMaxPendingSwaps = 1;
 }  // namespace
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
-      output_surface_state_(OUTPUT_SURFACE_NONE),
+      compositor_frame_sink_state_(COMPOSITOR_FRAME_SINK_NONE),
       begin_impl_frame_state_(BEGIN_IMPL_FRAME_STATE_IDLE),
       begin_main_frame_state_(BEGIN_MAIN_FRAME_STATE_IDLE),
       forced_redraw_state_(FORCED_REDRAW_STATE_IDLE),
       commit_count_(0),
       current_frame_number_(0),
       last_frame_number_swap_performed_(-1),
       last_frame_number_draw_performed_(-1),
       last_frame_number_begin_main_frame_sent_(-1),
-      last_frame_number_invalidate_output_surface_performed_(-1),
+      last_frame_number_invalidate_compositor_frame_sink_performed_(-1),
       draw_funnel_(false),
       send_begin_main_frame_funnel_(true),
-      invalidate_output_surface_funnel_(false),
+      invalidate_compositor_frame_sink_funnel_(false),
       prepare_tiles_funnel_(0),
       consecutive_checkerboard_animations_(0),
       pending_swaps_(0),
-      swaps_with_current_output_surface_(0),
+      swaps_with_current_compositor_frame_sink_(0),
       needs_redraw_(false),
       needs_prepare_tiles_(false),
       needs_begin_main_frame_(false),
       needs_one_begin_impl_frame_(false),
       visible_(false),
       begin_frame_source_paused_(false),
       resourceless_draw_(false),
       can_draw_(false),
       has_pending_tree_(false),
       pending_tree_is_ready_for_activation_(false),
       active_tree_needs_first_draw_(false),
-      did_create_and_initialize_first_output_surface_(false),
+      did_create_and_initialize_first_compositor_frame_sink_(false),
       tree_priority_(NEW_CONTENT_TAKES_PRIORITY),
       scroll_handler_state_(
           ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER),
       critical_begin_main_frame_to_activate_is_fast_(true),
       main_thread_missed_last_deadline_(false),
       skip_next_begin_main_frame_to_reduce_latency_(false),
       defer_commits_(false),
       video_needs_begin_frames_(false),
       last_commit_had_no_updates_(false),
       wait_for_ready_to_draw_(false),
       did_draw_in_last_frame_(false),
       did_swap_in_last_frame_(false) {}
 
-const char* SchedulerStateMachine::OutputSurfaceStateToString(
-    OutputSurfaceState state) {
+const char* SchedulerStateMachine::CompositorFrameSinkStateToString(
+    CompositorFrameSinkState state) {
   switch (state) {
-    case OUTPUT_SURFACE_NONE:
-      return "OUTPUT_SURFACE_NONE";
-    case OUTPUT_SURFACE_ACTIVE:
-      return "OUTPUT_SURFACE_ACTIVE";
-    case OUTPUT_SURFACE_CREATING:
-      return "OUTPUT_SURFACE_CREATING";
-    case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
-      return "OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT";
-    case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION:
-      return "OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION";
+    case COMPOSITOR_FRAME_SINK_NONE:
+      return "COMPOSITOR_FRAME_SINK_NONE";
+    case COMPOSITOR_FRAME_SINK_ACTIVE:
+      return "COMPOSITOR_FRAME_SINK_ACTIVE";
+    case COMPOSITOR_FRAME_SINK_CREATING:
+      return "COMPOSITOR_FRAME_SINK_CREATING";
+    case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT:
+      return "COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT";
+    case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION:
+      return "COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION";
   }
   NOTREACHED();
   return "???";
 }
 
 const char* SchedulerStateMachine::BeginImplFrameStateToString(
     BeginImplFrameState state) {
   switch (state) {
     case BEGIN_IMPL_FRAME_STATE_IDLE:
       return "BEGIN_IMPL_FRAME_STATE_IDLE";
@@ skipping 80 matching lines @@
     case ACTION_COMMIT:
       return "ACTION_COMMIT";
     case ACTION_ACTIVATE_SYNC_TREE:
       return "ACTION_ACTIVATE_SYNC_TREE";
     case ACTION_DRAW_AND_SWAP_IF_POSSIBLE:
       return "ACTION_DRAW_AND_SWAP_IF_POSSIBLE";
     case ACTION_DRAW_AND_SWAP_FORCED:
       return "ACTION_DRAW_AND_SWAP_FORCED";
     case ACTION_DRAW_AND_SWAP_ABORT:
       return "ACTION_DRAW_AND_SWAP_ABORT";
-    case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
-      return "ACTION_BEGIN_OUTPUT_SURFACE_CREATION";
+    case ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION:
+      return "ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION";
     case ACTION_PREPARE_TILES:
       return "ACTION_PREPARE_TILES";
-    case ACTION_INVALIDATE_OUTPUT_SURFACE:
-      return "ACTION_INVALIDATE_OUTPUT_SURFACE";
+    case ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK:
+      return "ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK";
   }
   NOTREACHED();
   return "???";
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 SchedulerStateMachine::AsValue() const {
   std::unique_ptr<base::trace_event::TracedValue> state(
       new base::trace_event::TracedValue());
   AsValueInto(state.get());
   return std::move(state);
 }
 
 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("begin_main_frame_state",
                    BeginMainFrameStateToString(begin_main_frame_state_));
-  state->SetString("output_surface_state_",
-                   OutputSurfaceStateToString(output_surface_state_));
+  state->SetString(
+      "compositor_frame_sink_state_",
+      CompositorFrameSinkStateToString(compositor_frame_sink_state_));
   state->SetString("forced_redraw_state",
                    ForcedRedrawOnTimeoutStateToString(forced_redraw_state_));
   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_swap_performed",
                     last_frame_number_swap_performed_);
   state->SetInteger("last_frame_number_draw_performed",
                     last_frame_number_draw_performed_);
   state->SetInteger("last_frame_number_begin_main_frame_sent",
                     last_frame_number_begin_main_frame_sent_);
   state->SetBoolean("funnel: draw_funnel", draw_funnel_);
   state->SetBoolean("funnel: send_begin_main_frame_funnel",
                     send_begin_main_frame_funnel_);
   state->SetInteger("funnel: prepare_tiles_funnel", prepare_tiles_funnel_);
-  state->SetBoolean("funnel: invalidate_output_surface_funnel",
-                    invalidate_output_surface_funnel_);
+  state->SetBoolean("funnel: invalidate_compositor_frame_sink_funnel",
+                    invalidate_compositor_frame_sink_funnel_);
   state->SetInteger("consecutive_checkerboard_animations",
                     consecutive_checkerboard_animations_);
   state->SetInteger("pending_swaps_", pending_swaps_);
-  state->SetInteger("swaps_with_current_output_surface",
-                    swaps_with_current_output_surface_);
+  state->SetInteger("swaps_with_current_compositor_frame_sink",
+                    swaps_with_current_compositor_frame_sink_);
   state->SetBoolean("needs_redraw", needs_redraw_);
   state->SetBoolean("needs_prepare_tiles", needs_prepare_tiles_);
   state->SetBoolean("needs_begin_main_frame", needs_begin_main_frame_);
   state->SetBoolean("needs_one_begin_impl_frame", needs_one_begin_impl_frame_);
   state->SetBoolean("visible", visible_);
   state->SetBoolean("begin_frame_source_paused", begin_frame_source_paused_);
   state->SetBoolean("can_draw", can_draw_);
   state->SetBoolean("resourceless_draw", resourceless_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("wait_for_ready_to_draw", wait_for_ready_to_draw_);
-  state->SetBoolean("did_create_and_initialize_first_output_surface",
-                    did_create_and_initialize_first_output_surface_);
+  state->SetBoolean("did_create_and_initialize_first_compositor_frame_sink",
+                    did_create_and_initialize_first_compositor_frame_sink_);
   state->SetString("tree_priority", TreePriorityToString(tree_priority_));
   state->SetString("scroll_handler_state",
                    ScrollHandlerStateToString(scroll_handler_state_));
   state->SetBoolean("critical_begin_main_frame_to_activate_is_fast_",
                     critical_begin_main_frame_to_activate_is_fast_);
   state->SetBoolean("main_thread_missed_last_deadline",
                     main_thread_missed_last_deadline_);
   state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
                     skip_next_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("video_needs_begin_frames", video_needs_begin_frames_);
   state->SetBoolean("defer_commits", defer_commits_);
   state->SetBoolean("last_commit_had_no_updates", last_commit_had_no_updates_);
   state->SetBoolean("did_draw_in_last_frame", did_draw_in_last_frame_);
   state->SetBoolean("did_swap_in_last_frame", did_swap_in_last_frame_);
   state->EndDictionary();
 }
 
 bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const {
   // Normally when |visible_| is false or |begin_frame_source_paused_| is true,
   // pending activations will be forced and draws will be aborted. However,
   // when the embedder is Android WebView, software draws could be scheduled by
   // the Android OS at any time and draws should not be aborted in this case.
-  bool is_output_surface_lost = (output_surface_state_ == OUTPUT_SURFACE_NONE);
+  bool is_compositor_frame_sink_lost =
+      (compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_NONE);
   if (resourceless_draw_)
-    return is_output_surface_lost || !can_draw_;
+    return is_compositor_frame_sink_lost || !can_draw_;
 
   // 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.
-  return is_output_surface_lost || !can_draw_ || !visible_ ||
+  return is_compositor_frame_sink_lost || !can_draw_ || !visible_ ||
          begin_frame_source_paused_;
 }
 
 bool SchedulerStateMachine::PendingActivationsShouldBeForced() const {
   // There is no output surface to trigger our activations.
   // If we do not force activations to make forward progress, we might deadlock
   // with the main thread.
-  if (output_surface_state_ == OUTPUT_SURFACE_NONE)
+  if (compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_NONE)
     return true;
 
   // If we're not visible, we should force activation.
   // Since we set RequiresHighResToDraw when becoming visible, we ensure that we
   // don't checkerboard until all visible resources are done. Furthermore, if we
   // do keep the pending tree around, when becoming visible we might activate
   // prematurely causing RequiresHighResToDraw flag to be reset. In all cases,
   // we can simply activate on becoming invisible since we don't need to draw
   // the active tree when we're in this state.
   if (!visible_)
     return true;
 
   // Force pending activations when BeginFrameSource is paused to avoid
   // deadlocking the main thread.
   if (begin_frame_source_paused_)
     return true;
 
   return false;
 }
 
-bool SchedulerStateMachine::ShouldBeginOutputSurfaceCreation() const {
+bool SchedulerStateMachine::ShouldBeginCompositorFrameSinkCreation() const {
   if (!visible_)
     return false;
 
   // We only want to start output surface initialization after the
   // previous commit is complete.
   // We make an exception if the embedder explicitly allows beginning output
   // surface creation while the previous commit has not been aborted. This
   // assumes that any state passed from the client during the commit will not be
   // tied to the output surface.
   if (begin_main_frame_state_ != BEGIN_MAIN_FRAME_STATE_IDLE &&
-      settings_.abort_commit_before_output_surface_creation) {
+      settings_.abort_commit_before_compositor_frame_sink_creation) {
     return false;
   }
 
-  // Make sure the BeginImplFrame from any previous OutputSurfaces
-  // are complete before creating the new OutputSurface.
+  // Make sure the BeginImplFrame from any previous CompositorFrameSinks
+  // are complete before creating the new CompositorFrameSink.
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_IDLE)
     return false;
 
   // We want to clear the pipeline of any pending draws and activations
   // before starting output surface initialization. This allows us to avoid
   // weird corner cases where we abort draws or force activation while we
   // are initializing the output surface.
   if (active_tree_needs_first_draw_ || has_pending_tree_)
     return false;
 
   // We need to create the output surface if we don't have one and we haven't
   // started creating one yet.
-  return output_surface_state_ == OUTPUT_SURFACE_NONE;
+  return compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_NONE;
 }
 
 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 occurring. If we are waiting for the first draw, then perform 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 (draw_funnel_)
     return false;
 
   // Don't draw if we are waiting on the first commit after a surface.
-  if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE)
+  if (compositor_frame_sink_state_ != COMPOSITOR_FRAME_SINK_ACTIVE)
     return false;
 
   // Do not queue too many swaps.
   if (SwapThrottled())
     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;
@@ skipping 76 matching lines @@
   if (!settings_.using_synchronous_renderer_compositor &&
       begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_IDLE) {
     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;
 
-  // We shouldn't normally accept commits if there isn't an OutputSurface.
-  if (!HasInitializedOutputSurface())
+  // We shouldn't normally accept commits if there isn't an CompositorFrameSink.
+  if (!HasInitializedCompositorFrameSink())
     return false;
 
   if (!settings_.main_frame_while_swap_throttled_enabled) {
     // SwapAck throttle the BeginMainFrames unless we just swapped to
     // potentially improve impl-thread latency over main-thread throughput.
     // TODO(brianderson): Remove this restriction to improve throughput or
     // make it conditional on ImplLatencyTakesPriority.
     bool just_swapped_in_deadline =
         begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
         did_swap_in_last_frame_;
@@ skipping 32 matching lines @@
     return false;
 
   // Limiting to once per-frame is not enough, since we only want to
   // prepare tiles _after_ draws.
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
     return false;
 
   return needs_prepare_tiles_;
 }
 
-bool SchedulerStateMachine::ShouldInvalidateOutputSurface() const {
+bool SchedulerStateMachine::ShouldInvalidateCompositorFrameSink() const {
   // Do not invalidate too many times in a frame.
-  if (invalidate_output_surface_funnel_)
+  if (invalidate_compositor_frame_sink_funnel_)
     return false;
 
   // Only the synchronous compositor requires invalidations.
   if (!settings_.using_synchronous_renderer_compositor)
     return false;
 
   // Invalidations are only performed inside a BeginFrame.
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)
     return false;
 
@@ skipping 13 matching lines @@
       return ACTION_DRAW_AND_SWAP_ABORT;
     else if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
       return ACTION_DRAW_AND_SWAP_FORCED;
     else
       return ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
   }
   if (ShouldPrepareTiles())
     return ACTION_PREPARE_TILES;
   if (ShouldSendBeginMainFrame())
     return ACTION_SEND_BEGIN_MAIN_FRAME;
-  if (ShouldInvalidateOutputSurface())
-    return ACTION_INVALIDATE_OUTPUT_SURFACE;
-  if (ShouldBeginOutputSurfaceCreation())
-    return ACTION_BEGIN_OUTPUT_SURFACE_CREATION;
+  if (ShouldInvalidateCompositorFrameSink())
+    return ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK;
+  if (ShouldBeginCompositorFrameSinkCreation())
+    return ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION;
   return ACTION_NONE;
 }
 
 void SchedulerStateMachine::WillSendBeginMainFrame() {
   DCHECK(!has_pending_tree_ || settings_.main_frame_before_activation_enabled);
   DCHECK(visible_);
   DCHECK(!begin_frame_source_paused_);
   DCHECK(!send_begin_main_frame_funnel_);
   begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_SENT;
   needs_begin_main_frame_ = false;
@@ skipping 22 matching lines @@
   }
 
   // Update state related to forced draws.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT) {
     forced_redraw_state_ = has_pending_tree_
                                ? FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION
                                : FORCED_REDRAW_STATE_WAITING_FOR_DRAW;
   }
 
   // Update the output surface state.
-  if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) {
-    output_surface_state_ = has_pending_tree_
-                                ? OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION
-                                : OUTPUT_SURFACE_ACTIVE;
+  if (compositor_frame_sink_state_ ==
+      COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT) {
+    compositor_frame_sink_state_ =
+        has_pending_tree_ ? COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION
+                          : COMPOSITOR_FRAME_SINK_ACTIVE;
   }
 }
 
 void SchedulerStateMachine::WillActivate() {
   if (begin_main_frame_state_ ==
       BEGIN_MAIN_FRAME_STATE_WAITING_FOR_ACTIVATION) {
     begin_main_frame_state_ = settings_.commit_to_active_tree
                                   ? BEGIN_MAIN_FRAME_STATE_WAITING_FOR_DRAW
                                   : BEGIN_MAIN_FRAME_STATE_IDLE;
   }
 
-  if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
-    output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
+  if (compositor_frame_sink_state_ ==
+      COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION)
+    compositor_frame_sink_state_ = COMPOSITOR_FRAME_SINK_ACTIVE;
 
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION)
     forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_DRAW;
 
   has_pending_tree_ = false;
   pending_tree_is_ready_for_activation_ = false;
   active_tree_needs_first_draw_ = true;
   needs_redraw_ = true;
 }
 
@@ skipping 73 matching lines @@
   // Note: We may abort at any time and cannot DCHECK that
   // we haven't drawn in or swapped in the last frame here.
   WillDrawInternal();
   DidDrawInternal(DRAW_ABORTED_DRAINING_PIPELINE);
 }
 
 void SchedulerStateMachine::WillPrepareTiles() {
   needs_prepare_tiles_ = false;
 }
 
-void SchedulerStateMachine::WillBeginOutputSurfaceCreation() {
-  DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_NONE);
-  output_surface_state_ = OUTPUT_SURFACE_CREATING;
+void SchedulerStateMachine::WillBeginCompositorFrameSinkCreation() {
+  DCHECK_EQ(compositor_frame_sink_state_, COMPOSITOR_FRAME_SINK_NONE);
+  compositor_frame_sink_state_ = COMPOSITOR_FRAME_SINK_CREATING;
 
   // The following DCHECKs make sure we are in the proper quiescent state.
   // The pipeline should be flushed entirely before we start output
   // surface creation to avoid complicated corner cases.
 
   // We allow output surface creation while the previous commit has not been
   // aborted if the embedder explicitly allows it.
-  DCHECK(!settings_.abort_commit_before_output_surface_creation ||
+  DCHECK(!settings_.abort_commit_before_compositor_frame_sink_creation ||
          begin_main_frame_state_ == BEGIN_MAIN_FRAME_STATE_IDLE);
   DCHECK(!has_pending_tree_);
   DCHECK(!active_tree_needs_first_draw_);
 }
 
-void SchedulerStateMachine::WillInvalidateOutputSurface() {
-  DCHECK(!invalidate_output_surface_funnel_);
-  invalidate_output_surface_funnel_ = true;
-  last_frame_number_invalidate_output_surface_performed_ =
+void SchedulerStateMachine::WillInvalidateCompositorFrameSink() {
+  DCHECK(!invalidate_compositor_frame_sink_funnel_);
+  invalidate_compositor_frame_sink_funnel_ = true;
+  last_frame_number_invalidate_compositor_frame_sink_performed_ =
       current_frame_number_;
 
   // The synchronous compositor makes no guarantees about a draw coming in after
   // an invalidate so clear any flags that would cause the compositor's pipeline
   // to stall.
   active_tree_needs_first_draw_ = false;  // blocks commit if true
 }
 
 void SchedulerStateMachine::SetSkipNextBeginMainFrameToReduceLatency() {
   TRACE_EVENT_INSTANT0("cc",
                        "Scheduler: SkipNextBeginMainFrameToReduceLatency",
                        TRACE_EVENT_SCOPE_THREAD);
   skip_next_begin_main_frame_to_reduce_latency_ = true;
 }
 
 bool SchedulerStateMachine::BeginFrameNeededForVideo() const {
   return video_needs_begin_frames_;
 }
 
 bool SchedulerStateMachine::BeginFrameNeeded() const {
   // We can't handle BeginFrames when output surface isn't initialized.
   // TODO(brianderson): Support output surface creation inside a BeginFrame.
-  if (!HasInitializedOutputSurface())
+  if (!HasInitializedCompositorFrameSink())
     return false;
 
   // If we are not visible, we don't need BeginFrame messages.
   if (!visible_)
     return false;
 
   return BeginFrameRequiredForAction() || BeginFrameNeededForVideo() ||
          ProactiveBeginFrameWanted();
 }
 
@@ skipping 68 matching lines @@
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME;
   current_frame_number_++;
 
   last_commit_had_no_updates_ = false;
   did_draw_in_last_frame_ = false;
   did_swap_in_last_frame_ = false;
   needs_one_begin_impl_frame_ = false;
 
   // Clear funnels for any actions we perform during the frame.
   send_begin_main_frame_funnel_ = false;
-  invalidate_output_surface_funnel_ = false;
+  invalidate_compositor_frame_sink_funnel_ = false;
 
   // "Drain" the PrepareTiles funnel.
   if (prepare_tiles_funnel_ > 0)
     prepare_tiles_funnel_--;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadline() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE;
 
   // Clear funnels for any actions we perform during the deadline.
@@ skipping 126 matching lines @@
     TRACE_EVENT0("cc", "SchedulerStateMachine::SetNeedsPrepareTiles");
     needs_prepare_tiles_ = true;
   }
 }
 void SchedulerStateMachine::DidSwapBuffers() {
   TRACE_EVENT_ASYNC_BEGIN1("cc", "Scheduler:pending_swaps", this,
                            "pending_frames", pending_swaps_);
   DCHECK_LT(pending_swaps_, kMaxPendingSwaps);
 
   pending_swaps_++;
-  swaps_with_current_output_surface_++;
+  swaps_with_current_compositor_frame_sink_++;
 
   did_swap_in_last_frame_ = true;
   last_frame_number_swap_performed_ = current_frame_number_;
 }
 
 void SchedulerStateMachine::DidSwapBuffersComplete() {
   TRACE_EVENT_ASYNC_END1("cc", "Scheduler:pending_swaps", this,
                          "pending_frames", pending_swaps_);
   pending_swaps_--;
 }
@@ skipping 45 matching lines @@
 }
 
 void SchedulerStateMachine::BeginMainFrameAborted(CommitEarlyOutReason reason) {
   DCHECK_EQ(begin_main_frame_state_, BEGIN_MAIN_FRAME_STATE_STARTED);
 
   // If the main thread aborted, it doesn't matter if the  main thread missed
   // the last deadline since it didn't have an update anyway.
   main_thread_missed_last_deadline_ = false;
 
   switch (reason) {
-    case CommitEarlyOutReason::ABORTED_OUTPUT_SURFACE_LOST:
+    case CommitEarlyOutReason::ABORTED_COMPOSITOR_FRAME_SINK_LOST:
     case CommitEarlyOutReason::ABORTED_NOT_VISIBLE:
     case CommitEarlyOutReason::ABORTED_DEFERRED_COMMIT:
       begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_IDLE;
       SetNeedsBeginMainFrame();
       return;
     case CommitEarlyOutReason::FINISHED_NO_UPDATES:
       bool commit_has_no_updates = true;
       WillCommit(commit_has_no_updates);
       return;
   }
 }
 
 void SchedulerStateMachine::DidPrepareTiles() {
   needs_prepare_tiles_ = false;
   // "Fill" the PrepareTiles funnel.
   prepare_tiles_funnel_++;
 }
 
-void SchedulerStateMachine::DidLoseOutputSurface() {
-  if (output_surface_state_ == OUTPUT_SURFACE_NONE ||
-      output_surface_state_ == OUTPUT_SURFACE_CREATING)
+void SchedulerStateMachine::DidLoseCompositorFrameSink() {
+  if (compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_NONE ||
+      compositor_frame_sink_state_ == COMPOSITOR_FRAME_SINK_CREATING)
     return;
-  output_surface_state_ = OUTPUT_SURFACE_NONE;
+  compositor_frame_sink_state_ = COMPOSITOR_FRAME_SINK_NONE;
   needs_redraw_ = false;
   wait_for_ready_to_draw_ = false;
 }
 
 void SchedulerStateMachine::NotifyReadyToActivate() {
   if (has_pending_tree_)
     pending_tree_is_ready_for_activation_ = true;
 }
 
 void SchedulerStateMachine::NotifyReadyToDraw() {
   wait_for_ready_to_draw_ = false;
 }
 
-void SchedulerStateMachine::DidCreateAndInitializeOutputSurface() {
-  DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_CREATING);
-  output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT;
+void SchedulerStateMachine::DidCreateAndInitializeCompositorFrameSink() {
+  DCHECK_EQ(compositor_frame_sink_state_, COMPOSITOR_FRAME_SINK_CREATING);
+  compositor_frame_sink_state_ = COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT;
 
-  if (did_create_and_initialize_first_output_surface_) {
+  if (did_create_and_initialize_first_compositor_frame_sink_) {
     // TODO(boliu): See if we can remove this when impl-side painting is always
     // on. Does anything on the main thread need to update after recreate?
     needs_begin_main_frame_ = true;
   }
-  did_create_and_initialize_first_output_surface_ = true;
+  did_create_and_initialize_first_compositor_frame_sink_ = true;
   pending_swaps_ = 0;
-  swaps_with_current_output_surface_ = 0;
+  swaps_with_current_compositor_frame_sink_ = 0;
   main_thread_missed_last_deadline_ = false;
 }
 
 void SchedulerStateMachine::NotifyBeginMainFrameStarted() {
   DCHECK_EQ(begin_main_frame_state_, BEGIN_MAIN_FRAME_STATE_SENT);
   begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_STARTED;
 }
 
-bool SchedulerStateMachine::HasInitializedOutputSurface() const {
-  switch (output_surface_state_) {
-    case OUTPUT_SURFACE_NONE:
-    case OUTPUT_SURFACE_CREATING:
+bool SchedulerStateMachine::HasInitializedCompositorFrameSink() const {
+  switch (compositor_frame_sink_state_) {
+    case COMPOSITOR_FRAME_SINK_NONE:
+    case COMPOSITOR_FRAME_SINK_CREATING:
       return false;
 
-    case OUTPUT_SURFACE_ACTIVE:
-    case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
-    case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION:
+    case COMPOSITOR_FRAME_SINK_ACTIVE:
+    case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT:
+    case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc