Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/scheduler/scheduler_unittest.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 <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 140 matching lines @@
     PushAction("ScheduledActionDrawAndSwapForced");
     return DRAW_SUCCESS;
   }
   void ScheduledActionCommit() override {
     PushAction("ScheduledActionCommit");
     scheduler_->DidCommit();
   }
   void ScheduledActionActivateSyncTree() override {
     PushAction("ScheduledActionActivateSyncTree");
   }
-  void ScheduledActionBeginOutputSurfaceCreation() override {
-    PushAction("ScheduledActionBeginOutputSurfaceCreation");
+  void ScheduledActionBeginCompositorFrameSinkCreation() override {
+    PushAction("ScheduledActionBeginCompositorFrameSinkCreation");
   }
   void ScheduledActionPrepareTiles() override {
     PushAction("ScheduledActionPrepareTiles");
     scheduler_->WillPrepareTiles();
     scheduler_->DidPrepareTiles();
   }
-  void ScheduledActionInvalidateOutputSurface() override {
-    actions_.push_back("ScheduledActionInvalidateOutputSurface");
+  void ScheduledActionInvalidateCompositorFrameSink() override {
+    actions_.push_back("ScheduledActionInvalidateCompositorFrameSink");
     states_.push_back(scheduler_->AsValue());
   }
 
   void SendBeginMainFrameNotExpectedSoon() override {
     PushAction("SendBeginMainFrameNotExpectedSoon");
   }
 
   bool IsInsideBeginImplFrame() const { return inside_begin_impl_frame_; }
 
   base::Callback<bool(void)> InsideBeginImplFrame(bool state) {
@@ skipping 83 matching lines @@
     client_->set_scheduler(scheduler_.get());
 
     // Use large estimates by default to avoid latency recovery in most tests.
     fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
 
     return scheduler_.get();
   }
 
   void CreateSchedulerAndInitSurface() {
     CreateScheduler();
-    EXPECT_SCOPED(InitializeOutputSurfaceAndFirstCommit());
+    EXPECT_SCOPED(InitializeCompositorFrameSinkAndFirstCommit());
   }
 
   void SetUpScheduler(bool initSurface) {
     SetUpScheduler(base::WrapUnique(new FakeSchedulerClient), initSurface);
   }
 
   void SetUpScheduler(std::unique_ptr<FakeSchedulerClient> client,
                       bool initSurface) {
     client_ = std::move(client);
     if (initSurface)
       CreateSchedulerAndInitSurface();
     else
       CreateScheduler();
   }
 
   OrderedSimpleTaskRunner& task_runner() { return *task_runner_; }
   base::SimpleTestTickClock* now_src() { return now_src_.get(); }
 
   // As this function contains EXPECT macros, to allow debugging it should be
   // called inside EXPECT_SCOPED like so;
-  //   EXPECT_SCOPED(client.InitializeOutputSurfaceAndFirstCommit(scheduler));
-  void InitializeOutputSurfaceAndFirstCommit() {
-    TRACE_EVENT0("cc",
-                 "SchedulerUnitTest::InitializeOutputSurfaceAndFirstCommit");
+  //   EXPECT_SCOPED(
+  //       client.InitializeCompositorFrameSinkAndFirstCommit(scheduler));
+  void InitializeCompositorFrameSinkAndFirstCommit() {
+    TRACE_EVENT0(
+        "cc", "SchedulerUnitTest::InitializeCompositorFrameSinkAndFirstCommit");
     DCHECK(scheduler_);
 
     // Check the client doesn't have any actions queued when calling this
     // function.
     EXPECT_NO_ACTION(client_);
     EXPECT_FALSE(scheduler_->begin_frames_expected());
 
-    // Start the initial output surface creation.
+    // Start the initial CompositorFrameSink creation.
     scheduler_->SetVisible(true);
     scheduler_->SetCanDraw(true);
-    EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
+    EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
+                         client_);
 
     client_->Reset();
 
     // We don't see anything happening until the first impl frame.
-    scheduler_->DidCreateAndInitializeOutputSurface();
+    scheduler_->DidCreateAndInitializeCompositorFrameSink();
     scheduler_->SetNeedsBeginMainFrame();
     EXPECT_TRUE(scheduler_->begin_frames_expected());
     EXPECT_FALSE(client_->IsInsideBeginImplFrame());
     client_->Reset();
 
     {
       SCOPED_TRACE("Do first frame to commit after initialize.");
       AdvanceFrame();
 
       scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
       scheduler_->NotifyReadyToCommit();
       scheduler_->NotifyReadyToActivate();
       scheduler_->NotifyReadyToDraw();
 
       EXPECT_FALSE(scheduler_->CommitPending());
 
       if (scheduler_settings_.using_synchronous_renderer_compositor) {
         scheduler_->SetNeedsRedraw();
         bool resourceless_software_draw = false;
-        scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+        scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
       } else {
         // Run the posted deadline task.
         EXPECT_TRUE(client_->IsInsideBeginImplFrame());
         task_runner_->RunTasksWhile(client_->InsideBeginImplFrame(true));
       }
 
       EXPECT_FALSE(client_->IsInsideBeginImplFrame());
     }
 
     client_->Reset();
@@ skipping 77 matching lines @@
   std::unique_ptr<FakeExternalBeginFrameSource>
       fake_external_begin_frame_source_;
   std::unique_ptr<SyntheticBeginFrameSource> synthetic_frame_source_;
   std::unique_ptr<SyntheticBeginFrameSource> unthrottled_frame_source_;
   SchedulerSettings scheduler_settings_;
   std::unique_ptr<FakeSchedulerClient> client_;
   std::unique_ptr<TestScheduler> scheduler_;
   FakeCompositorTimingHistory* fake_compositor_timing_history_;
 };
 
-TEST_F(SchedulerTest, InitializeOutputSurfaceDoesNotBeginImplFrame) {
+TEST_F(SchedulerTest, InitializeCompositorFrameSinkDoesNotBeginImplFrame) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
 
-  EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
+                       client_);
   client_->Reset();
-  scheduler_->DidCreateAndInitializeOutputSurface();
+  scheduler_->DidCreateAndInitializeCompositorFrameSink();
   EXPECT_NO_ACTION(client_);
 }
 
 TEST_F(SchedulerTest, VideoNeedsBeginFrames) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   scheduler_->SetVideoNeedsBeginFrames(true);
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   EXPECT_TRUE(scheduler_->begin_frames_expected());
@@ skipping 176 matching lines @@
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // Because we just swapped, the Scheduler should also request the next
-  // BeginImplFrame from the OutputSurface.
+  // BeginImplFrame from the CompositorFrameSink.
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
   // Since another commit is needed, the next BeginImplFrame should initiate
   // the second commit.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
@@ skipping 578 matching lines @@
   EXPECT_NO_ACTION(client_);
 
   // Scheduler received ready to draw signal, and posted deadline.
   scheduler_->NotifyReadyToDraw();
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
   EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
 }
 
-TEST_F(SchedulerTest, WaitForReadyToDrawCancelledWhenLostOutputSurface) {
+TEST_F(SchedulerTest, WaitForReadyToDrawCancelledWhenLostCompositorFrameSink) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.commit_to_active_tree = true;
   SetUpScheduler(base::WrapUnique(client), true);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
@@ skipping 11 matching lines @@
   client_->Reset();
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
 
   // Scheduler won't post deadline in the mode.
   client_->Reset();
   task_runner().RunPendingTasks();  // Try to run posted deadline.
   // There is no posted deadline.
   EXPECT_NO_ACTION(client_);
 
-  // Scheduler loses output surface, and stops waiting for ready to draw signal.
+  // Scheduler loses CompositorFrameSink, and stops waiting for ready to draw
+  // signal.
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
+                3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
 void SchedulerTest::CheckMainFrameSkippedAfterLateCommit(
     bool expect_send_begin_main_frame) {
   // Impl thread hits deadline before commit finishes.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
@@ skipping 1185 matching lines @@
 }
 
 TEST_F(SchedulerTest,
        SyntheticBeginFrames_And_VSyncThrottlingDisabled_SwapThrottled) {
   bool use_external_begin_frame_source = false;
   bool throttle_frame_production = false;
   BeginFramesNotFromClient_SwapThrottled(use_external_begin_frame_source,
                                          throttle_frame_production);
 }
 
-TEST_F(SchedulerTest, DidLoseOutputSurfaceAfterOutputSurfaceIsInitialized) {
+TEST_F(SchedulerTest,
+       DidLoseCompositorFrameSinkAfterCompositorFrameSinkIsInitialized) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
 
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
 
-  EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
+                       client_);
   client_->Reset();
-  scheduler_->DidCreateAndInitializeOutputSurface();
+  scheduler_->DidCreateAndInitializeCompositorFrameSink();
   EXPECT_NO_ACTION(client_);
 
-  scheduler_->DidLoseOutputSurface();
-  EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
+  scheduler_->DidLoseCompositorFrameSink();
+  EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
+                       client_);
 }
 
-TEST_F(SchedulerTest, DidLoseOutputSurfaceAfterBeginFrameStarted) {
+TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterBeginFrameStarted) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   // RemoveObserver(this) is not called until the end of the frame.
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_ACTION("ScheduledActionCommit", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 2);
 
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
+                3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
 TEST_F(SchedulerTest,
-       DidLoseOutputSurfaceAfterBeginFrameStartedWithHighLatency) {
+       DidLoseCompositorFrameSinkAfterBeginFrameStartedWithHighLatency) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   // Do nothing when impl frame is in deadine pending state.
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
   // Run posted deadline.
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
-  // OnBeginImplFrameDeadline didn't schedule output surface creation because
+  // OnBeginImplFrameDeadline didn't schedule CompositorFrameSink creation
+  // because
   // main frame is not yet completed.
   EXPECT_ACTION("RemoveObserver(this)", client_, 0, 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // BeginImplFrame is not started.
   client_->Reset();
   task_runner().RunUntilTime(now_src()->NowTicks() +
                              base::TimeDelta::FromMilliseconds(10));
   EXPECT_NO_ACTION(client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_ACTION("ScheduledActionCommit", client_, 0, 3);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 3);
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 2, 3);
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 2,
+                3);
 }
 
-TEST_F(SchedulerTest, DidLoseOutputSurfaceAfterReadyToCommit) {
+TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterReadyToCommit) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
 
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   // Sync tree should be forced to activate.
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
 
   // RemoveObserver(this) is not called until the end of the frame.
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
+                3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
-TEST_F(SchedulerTest, DidLoseOutputSurfaceAfterSetNeedsPrepareTiles) {
+TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterSetNeedsPrepareTiles) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   // RemoveObserver(this) is not called until the end of the frame.
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 0, 4);
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 1, 4);
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 1,
+                4);
   EXPECT_ACTION("RemoveObserver(this)", client_, 2, 4);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 3, 4);
 }
 
-TEST_F(SchedulerTest, DidLoseOutputSurfaceAfterBeginRetroFramePosted) {
+TEST_F(SchedulerTest, DidLoseCompositorFrameSinkAfterBeginRetroFramePosted) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   // Create a BeginFrame with a long deadline to avoid race conditions.
   // This is the first BeginFrame, which will be handled immediately.
   client_->Reset();
@@ skipping 27 matching lines @@
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   // NotifyReadyToActivate should trigger the activation.
   client_->Reset();
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   EXPECT_FALSE(scheduler_->IsBeginRetroFrameArgsEmpty());
-  scheduler_->DidLoseOutputSurface();
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
+  scheduler_->DidLoseCompositorFrameSink();
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
+                3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_TRUE(scheduler_->IsBeginRetroFrameArgsEmpty());
 
   // Posted BeginRetroFrame is aborted.
   client_->Reset();
   task_runner().RunPendingTasks();
   EXPECT_NO_ACTION(client_);
 }
 
-TEST_F(SchedulerTest, DidLoseOutputSurfaceDuringBeginRetroFrameRunning) {
+TEST_F(SchedulerTest, DidLoseCompositorFrameSinkDuringBeginRetroFrameRunning) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   // Create a BeginFrame with a long deadline to avoid race conditions.
   // This is the first BeginFrame, which will be handled immediately.
   client_->Reset();
@@ skipping 34 matching lines @@
 
   // BeginImplFrame should prepare the draw.
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted BeginRetroFrame.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   EXPECT_FALSE(scheduler_->IsBeginRetroFrameArgsEmpty());
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   EXPECT_NO_ACTION(client_);
   EXPECT_TRUE(scheduler_->IsBeginRetroFrameArgsEmpty());
 
   // BeginImplFrame deadline should abort drawing.
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
+                3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_FALSE(scheduler_->begin_frames_expected());
 
   // No more BeginRetroFrame because BeginRetroFrame queue is cleared.
   client_->Reset();
   task_runner().RunPendingTasks();
   EXPECT_NO_ACTION(client_);
 }
 
-TEST_F(SchedulerTest, DidLoseOutputSurfaceWithDelayBasedBeginFrameSource) {
+TEST_F(SchedulerTest,
+       DidLoseCompositorFrameSinkWithDelayBasedBeginFrameSource) {
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   EXPECT_FALSE(scheduler_->begin_frames_expected());
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   // NotifyReadyToCommit should trigger the commit.
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   // NotifyReadyToActivate should trigger the activation.
   client_->Reset();
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   // RemoveObserver(this) is not called until the end of the frame.
   EXPECT_NO_ACTION(client_);
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 2);
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
+                2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   EXPECT_FALSE(scheduler_->begin_frames_expected());
 }
 
-TEST_F(SchedulerTest, DidLoseOutputSurfaceWhenIdle) {
+TEST_F(SchedulerTest, DidLoseCompositorFrameSinkWhenIdle) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
 
   client_->Reset();
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
 
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
 
   // Idle time between BeginFrames.
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
+  scheduler_->DidLoseCompositorFrameSink();
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
+                3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
 TEST_F(SchedulerTest, ScheduledActionActivateAfterBecomingInvisible) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
@@ skipping 229 matching lines @@
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
 
   client_->Reset();
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
 
   client_->Reset();
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
 
-  // Scheduler loses output surface, and stops waiting for ready to draw signal.
+  // Scheduler loses CompositorFrameSink, and stops waiting for ready to draw
+  // signal.
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   task_runner().RunPendingTasks();
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
+                3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 
   // Changing begin frame source doesn't do anything.
   // The unthrottled source doesn't print Add/RemoveObserver like the fake one.
   client_->Reset();
   scheduler_->SetBeginFrameSource(unthrottled_frame_source_.get());
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
-  scheduler_->DidCreateAndInitializeOutputSurface();
+  scheduler_->DidCreateAndInitializeCompositorFrameSink();
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_NO_ACTION(client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
@@ skipping 45 matching lines @@
   client_->Reset();
 
   // Testing the case where animation ticks a fling scroll.
   client_->SetWillBeginImplFrameCausesRedraw(true);
   // The animation isn't done so it'll cause another tick in the future.
   client_->SetWillBeginImplFrameRequestsOneBeginImplFrame(true);
 
   // Next vsync.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
-  EXPECT_ACTION("ScheduledActionInvalidateOutputSurface", client_, 1, 2);
+  EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Android onDraw. This doesn't consume the single begin frame request.
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
-  scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+  scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // The animation inside of WillBeginImplFrame changes stuff on the screen, but
   // ends here, so does not cause another frame to happen.
   client_->SetWillBeginImplFrameCausesRedraw(true);
 
   // Next vsync.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
-  EXPECT_ACTION("ScheduledActionInvalidateOutputSurface", client_, 1, 2);
+  EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
-  scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+  scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Idle on next vsync, as the animation has completed.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorOnDrawDuringIdle) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
-  scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+  scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_ACTION("AddObserver(this)", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Idle on next vsync.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
@@ skipping 68 matching lines @@
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   client_->Reset();
 
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
   client_->Reset();
 
   // Next vsync.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
-  EXPECT_ACTION("ScheduledActionInvalidateOutputSurface", client_, 1, 2);
+  EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
-  scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+  scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Idle on next vsync.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
@@ skipping 26 matching lines @@
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
   client_->Reset();
 
   // Ask for another commit.
   scheduler_->SetNeedsBeginMainFrame();
 
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 3);
-  EXPECT_ACTION("ScheduledActionInvalidateOutputSurface", client_, 2, 3);
+  EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   EXPECT_NO_ACTION(client_);
 
   // Allow new commit even though previous commit hasn't been drawn.
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   client_->Reset();
@@ skipping 18 matching lines @@
       base::WrapUnique(new SchedulerClientSetNeedsPrepareTilesOnDraw);
   SetUpScheduler(std::move(client), true);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Next vsync.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
-  EXPECT_ACTION("ScheduledActionInvalidateOutputSurface", client_, 1, 2);
+  EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
-  scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+  scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
-  scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+  scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   client_->Reset();
 
   // Next vsync.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(scheduler_->begin_frames_expected());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorSendBeginMainFrameWhileIdle) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
   scheduler_settings_.use_external_begin_frame_source = true;
 
   SetUpScheduler(true);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Next vsync.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
-  EXPECT_ACTION("ScheduledActionInvalidateOutputSurface", client_, 1, 2);
+  EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
-  scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+  scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   client_->Reset();
 
   // Simulate SetNeedsBeginMainFrame due to input event.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("ScheduledActionSendBeginMainFrame", client_);
   client_->Reset();
 
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   client_->Reset();
 
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
   client_->Reset();
 
   // Next vsync.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
-  EXPECT_ACTION("ScheduledActionInvalidateOutputSurface", client_, 1, 2);
+  EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
-  scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+  scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   client_->Reset();
 
   // Simulate SetNeedsBeginMainFrame due to input event.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("ScheduledActionSendBeginMainFrame", client_);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorResourcelessOnDrawWhenInvisible) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   scheduler_->SetVisible(false);
 
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = true;
-  scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
+  scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   // SynchronousCompositor has to draw regardless of visibility.
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, AuthoritativeVSyncInterval) {
   SetUpScheduler(true);
   base::TimeDelta initial_interval = scheduler_->BeginImplFrameInterval();
   base::TimeDelta authoritative_interval =
@@ skipping 50 matching lines @@
 
   scheduler_->SetTreePrioritiesAndScrollState(
       SAME_PRIORITY_FOR_BOTH_TREES,
       ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER);
   scheduler_->SetCriticalBeginMainFrameToActivateIsFast(true);
   EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
   scheduler_->SetCriticalBeginMainFrameToActivateIsFast(false);
   EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
 }
 
-TEST_F(SchedulerTest, NoOutputSurfaceCreationWhileCommitPending) {
+TEST_F(SchedulerTest, NoCompositorFrameSinkCreationWhileCommitPending) {
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
 
-  // Lose the output surface and trigger the deadline.
+  // Lose the CompositorFrameSink and trigger the deadline.
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_NO_ACTION(client_);
 
-  // The scheduler should not trigger the output surface creation till the
+  // The scheduler should not trigger the CompositorFrameSink creation till the
   // commit is aborted.
   task_runner_->RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_SINGLE_ACTION("SendBeginMainFrameNotExpectedSoon", client_);
 
   // Abort the commit.
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks::Now());
   scheduler_->BeginMainFrameAborted(
-      CommitEarlyOutReason::ABORTED_OUTPUT_SURFACE_LOST);
-  EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
+      CommitEarlyOutReason::ABORTED_COMPOSITOR_FRAME_SINK_LOST);
+  EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
+                       client_);
 }
 
-TEST_F(SchedulerTest, OutputSurfaceCreationWhileCommitPending) {
-  scheduler_settings_.abort_commit_before_output_surface_creation = false;
+TEST_F(SchedulerTest, CompositorFrameSinkCreationWhileCommitPending) {
+  scheduler_settings_.abort_commit_before_compositor_frame_sink_creation =
+      false;
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame.
   scheduler_->SetNeedsBeginMainFrame();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
 
-  // Lose the output surface and trigger the deadline.
+  // Lose the CompositorFrameSink and trigger the deadline.
   client_->Reset();
-  scheduler_->DidLoseOutputSurface();
+  scheduler_->DidLoseCompositorFrameSink();
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_NO_ACTION(client_);
 
-  // The scheduler should trigger the output surface creation immediately after
+  // The scheduler should trigger the CompositorFrameSink creation immediately
+  // after
   // the begin_impl_frame_state_ is cleared.
   task_runner_->RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 2);
+  EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
+                2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
 }
 
 // The three letters appeneded to each version of this test mean the following:s
 // tree_priority: B = both trees same priority; A = active tree priority;
 // scroll_handler_state: H = affects scroll handler; N = does not affect scroll
 // handler;
 // durations: F = fast durations; S = slow durations
 bool SchedulerTest::BeginMainFrameOnCriticalPath(
     TreePriority tree_priority,
@@ skipping 59 matching lines @@
 }
 
 TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_AHS) {
   EXPECT_FALSE(BeginMainFrameOnCriticalPath(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER, kSlowDuration));
 }
 
 }  // namespace
 }  // namespace cc