cc: Rename SwapBuffers on CompositorFrameSink to SubmitCompositorFrame

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 39 matching lines @@
 namespace {
 
 base::TimeDelta kSlowDuration = base::TimeDelta::FromSeconds(1);
 base::TimeDelta kFastDuration = base::TimeDelta::FromMilliseconds(1);
 
 class FakeSchedulerClient : public SchedulerClient,
                             public FakeExternalBeginFrameSource::Client {
  public:
   FakeSchedulerClient()
       : inside_begin_impl_frame_(false),
-        automatic_swap_ack_(true),
+        automatic_ack_(true),
         scheduler_(nullptr) {
     Reset();
   }
 
   void Reset() {
     actions_.clear();
     states_.clear();
     will_begin_impl_frame_causes_redraw_ = false;
     will_begin_impl_frame_requests_one_begin_impl_frame_ = false;
     draw_will_happen_ = true;
@@ skipping 27 matching lines @@
   }
   void SetWillBeginImplFrameCausesRedraw(bool causes_redraw) {
     will_begin_impl_frame_causes_redraw_ = causes_redraw;
   }
   void SetDrawWillHappen(bool draw_will_happen) {
     draw_will_happen_ = draw_will_happen;
   }
   void SetSwapWillHappenIfDrawHappens(bool swap_will_happen_if_draw_happens) {
     swap_will_happen_if_draw_happens_ = swap_will_happen_if_draw_happens;
   }
-  void SetAutomaticSwapAck(bool automatic_swap_ack) {
-    automatic_swap_ack_ = automatic_swap_ack;
+  void SetAutomaticSubmitCompositorFrameAck(bool automatic_ack) {
+    automatic_ack_ = automatic_ack;
   }
   // SchedulerClient implementation.
   void WillBeginImplFrame(const BeginFrameArgs& args) override {
     EXPECT_FALSE(inside_begin_impl_frame_);
     inside_begin_impl_frame_ = true;
     PushAction("WillBeginImplFrame");
     if (will_begin_impl_frame_requests_one_begin_impl_frame_)
       scheduler_->SetNeedsOneBeginImplFrame();
     if (will_begin_impl_frame_causes_redraw_)
       scheduler_->SetNeedsRedraw();
   }
   void DidFinishImplFrame() override {
     EXPECT_TRUE(inside_begin_impl_frame_);
     inside_begin_impl_frame_ = false;
   }
 
   void ScheduledActionSendBeginMainFrame(const BeginFrameArgs& args) override {
     PushAction("ScheduledActionSendBeginMainFrame");
     last_begin_main_frame_args_ = args;
   }
 
   const BeginFrameArgs& last_begin_main_frame_args() {
     return last_begin_main_frame_args_;
   }
 
-  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
-    PushAction("ScheduledActionDrawAndSwapIfPossible");
+  DrawResult ScheduledActionDrawIfPossible() override {
+    PushAction("ScheduledActionDrawIfPossible");
     num_draws_++;
     DrawResult result =
         draw_will_happen_ ? DRAW_SUCCESS : DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
     bool swap_will_happen =
         draw_will_happen_ && swap_will_happen_if_draw_happens_;
     if (swap_will_happen) {
-      scheduler_->DidSwapBuffers();
+      scheduler_->DidSubmitCompositorFrame();
 
-      if (automatic_swap_ack_)
-        scheduler_->DidSwapBuffersComplete();
+      if (automatic_ack_)
+        scheduler_->DidReceiveCompositorFrameAck();
     }
     return result;
   }
-  DrawResult ScheduledActionDrawAndSwapForced() override {
-    PushAction("ScheduledActionDrawAndSwapForced");
+  DrawResult ScheduledActionDrawForced() override {
+    PushAction("ScheduledActionDrawForced");
     return DRAW_SUCCESS;
   }
   void ScheduledActionCommit() override {
     PushAction("ScheduledActionCommit");
     scheduler_->DidCommit();
   }
   void ScheduledActionActivateSyncTree() override {
     PushAction("ScheduledActionActivateSyncTree");
   }
   void ScheduledActionBeginCompositorFrameSinkCreation() override {
@@ skipping 46 matching lines @@
  protected:
   bool InsideBeginImplFrameCallback(bool state) {
     return inside_begin_impl_frame_ == state;
   }
 
   bool inside_begin_impl_frame_;
   bool will_begin_impl_frame_causes_redraw_;
   bool will_begin_impl_frame_requests_one_begin_impl_frame_;
   bool draw_will_happen_;
   bool swap_will_happen_if_draw_happens_;
-  bool automatic_swap_ack_;
+  bool automatic_ack_;
   int num_draws_;
   BeginFrameArgs last_begin_main_frame_args_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<std::unique_ptr<base::trace_event::ConvertableToTraceFormat>>
       states_;
   TestScheduler* scheduler_;
 };
 
 enum BeginFrameSourceType {
@@ skipping 180 matching lines @@
         CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
     fake_external_begin_frame_source_->TestOnBeginFrame(args);
     return args;
   }
 
   FakeExternalBeginFrameSource* fake_external_begin_frame_source() const {
     return fake_external_begin_frame_source_.get();
   }
 
   void CheckMainFrameSkippedAfterLateCommit(bool expect_send_begin_main_frame);
-  void ImplFrameSkippedAfterLateSwapAck(bool swap_ack_before_deadline);
-  void ImplFrameNotSkippedAfterLateSwapAck();
+  void ImplFrameSkippedAfterLateAck(bool receive_ack_before_deadline);
+  void ImplFrameNotSkippedAfterLateAck();
   void BeginFramesNotFromClient(BeginFrameSourceType bfs_type);
-  void BeginFramesNotFromClient_SwapThrottled(BeginFrameSourceType bfs_type);
+  void BeginFramesNotFromClient_IsDrawThrottled(BeginFrameSourceType bfs_type);
   bool BeginMainFrameOnCriticalPath(TreePriority tree_priority,
                                     ScrollHandlerState scroll_handler_state,
                                     base::TimeDelta durations);
 
   std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   std::unique_ptr<FakeExternalBeginFrameSource>
       fake_external_begin_frame_source_;
   std::unique_ptr<SyntheticBeginFrameSource> synthetic_frame_source_;
   std::unique_ptr<SyntheticBeginFrameSource> unthrottled_frame_source_;
@@ skipping 97 matching lines @@
 
   // BeginImplFrame should prepare the draw.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   // BeginImplFrame deadline should draw.
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   // The following BeginImplFrame deadline should SetNeedsBeginFrame(false)
   // to avoid excessive toggles.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
@@ skipping 44 matching lines @@
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   AdvanceFrame();
   // BeginMainFrame is not sent during the defer commit is on.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   AdvanceFrame();
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
 }
 
 TEST_F(SchedulerTest, RequestCommitAfterBeginMainFrameSent) {
   SetUpScheduler(EXTERNAL_BFS);
@@ skipping 24 matching lines @@
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Activate it.
   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_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // Because we just swapped, the Scheduler should also request the next
   // 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();
 
   // Finishing the commit before the deadline should post a new deadline task
   // to trigger the deadline early.
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
   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_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   // On the next BeginImplFrame, verify we go back to a quiescent state and
   // no longer request BeginImplFrames.
   EXPECT_SCOPED(AdvanceFrame());
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_FALSE(scheduler_->begin_frames_expected());
   client_->Reset();
 }
 
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
   SchedulerClientThatsetNeedsDrawInsideDraw()
       : FakeSchedulerClient(), request_redraws_(false) {}
 
   void SetRequestRedrawsInsideDraw(bool enable) { request_redraws_ = enable; }
 
-  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
+  DrawResult ScheduledActionDrawIfPossible() override {
     // Only SetNeedsRedraw the first time this is called
     if (request_redraws_) {
       scheduler_->SetNeedsRedraw();
     }
-    return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
+    return FakeSchedulerClient::ScheduledActionDrawIfPossible();
   }
 
-  DrawResult ScheduledActionDrawAndSwapForced() override {
+  DrawResult ScheduledActionDrawForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
  private:
   bool request_redraws_;
 };
 
 // Tests for two different situations:
 // 1. the scheduler dropping SetNeedsRedraw requests that happen inside
-//    a ScheduledActionDrawAndSwap
+//    a ScheduledActionDraw
 // 2. the scheduler drawing twice inside a single tick
 TEST_F(SchedulerTest, RequestRedrawInsideDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw* client =
       new SchedulerClientThatsetNeedsDrawInsideDraw;
   SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
   client->SetRequestRedrawsInsideDraw(true);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
@@ skipping 66 matching lines @@
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
 }
 
 class SchedulerClientThatSetNeedsBeginMainFrameInsideDraw
     : public FakeSchedulerClient {
  public:
   SchedulerClientThatSetNeedsBeginMainFrameInsideDraw()
       : set_needs_commit_on_next_draw_(false) {}
 
-  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
+  DrawResult ScheduledActionDrawIfPossible() override {
     // Only SetNeedsBeginMainFrame the first time this is called
     if (set_needs_commit_on_next_draw_) {
       scheduler_->SetNeedsBeginMainFrame();
       set_needs_commit_on_next_draw_ = false;
     }
-    return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
+    return FakeSchedulerClient::ScheduledActionDrawIfPossible();
   }
 
-  DrawResult ScheduledActionDrawAndSwapForced() override {
+  DrawResult ScheduledActionDrawForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
   void SetNeedsBeginMainFrameOnNextDraw() {
     set_needs_commit_on_next_draw_ = true;
   }
 
  private:
   bool set_needs_commit_on_next_draw_;
 };
 
 // Tests for the scheduler infinite-looping on SetNeedsBeginMainFrame requests
-// that happen inside a ScheduledActionDrawAndSwap
+// that happen inside a ScheduledActionDraw
 TEST_F(SchedulerTest, RequestCommitInsideDraw) {
   SchedulerClientThatSetNeedsBeginMainFrameInsideDraw* client =
       new SchedulerClientThatSetNeedsBeginMainFrameInsideDraw;
   SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   EXPECT_FALSE(client->needs_begin_frames());
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_EQ(0, client->num_draws());
   EXPECT_TRUE(client->needs_begin_frames());
@@ skipping 93 matching lines @@
   // Fail to draw, this should not start a frame.
   client->SetDrawWillHappen(false);
   client->SetNeedsBeginMainFrameOnNextDraw();
   EXPECT_SCOPED(AdvanceFrame());
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(2, client->num_draws());
 }
 
 class SchedulerClientNeedsPrepareTilesInDraw : public FakeSchedulerClient {
  public:
-  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
+  DrawResult ScheduledActionDrawIfPossible() override {
     scheduler_->SetNeedsPrepareTiles();
-    return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
+    return FakeSchedulerClient::ScheduledActionDrawIfPossible();
   }
 };
 
 // Test prepare tiles is independant of draws.
 TEST_F(SchedulerTest, PrepareTiles) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
   SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   // Request both draw and prepare tiles. PrepareTiles shouldn't
   // be trigged until BeginImplFrame.
   client->Reset();
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
   EXPECT_FALSE(client->HasAction("ScheduledActionPrepareTiles"));
-  EXPECT_FALSE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_FALSE(client->HasAction("ScheduledActionDrawIfPossible"));
 
   // We have no immediate actions to perform, so the BeginImplFrame should post
   // the deadline task.
   client->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   // On the deadline, the actions should have occured in the right order.
   client->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client->num_draws());
-  EXPECT_TRUE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client->HasAction("ScheduledActionDrawIfPossible"));
   EXPECT_TRUE(client->HasAction("ScheduledActionPrepareTiles"));
-  EXPECT_LT(client->ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
+  EXPECT_LT(client->ActionIndex("ScheduledActionDrawIfPossible"),
             client->ActionIndex("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // Request a draw. We don't need a PrepareTiles yet.
   client->Reset();
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
 
   // We have no immediate actions to perform, so the BeginImplFrame should post
   // the deadline task.
   client->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   // Draw. The draw will trigger SetNeedsPrepareTiles, and
   // then the PrepareTiles action will be triggered after the Draw.
   // Afterwards, neither a draw nor PrepareTiles are pending.
   client->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client->num_draws());
-  EXPECT_TRUE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client->HasAction("ScheduledActionDrawIfPossible"));
   EXPECT_TRUE(client->HasAction("ScheduledActionPrepareTiles"));
-  EXPECT_LT(client->ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
+  EXPECT_LT(client->ActionIndex("ScheduledActionDrawIfPossible"),
             client->ActionIndex("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // We need a BeginImplFrame where we don't swap to go idle.
   client->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 14 matching lines @@
   EXPECT_FALSE(scheduler_->RedrawPending());
 
   // BeginImplFrame. There will be no draw, only PrepareTiles.
   client->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(0, client->num_draws());
-  EXPECT_FALSE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_FALSE(client->HasAction("ScheduledActionDrawIfPossible"));
   EXPECT_TRUE(client->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 }
 
 // Test that PrepareTiles only happens once per frame.  If an external caller
 // initiates it, then the state machine should not PrepareTiles on that frame.
 TEST_F(SchedulerTest, PrepareTilesOncePerFrame) {
   SetUpScheduler(EXTERNAL_BFS);
 
   // If DidPrepareTiles during a frame, then PrepareTiles should not occur
   // again.
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
   scheduler_->WillPrepareTiles();
   scheduler_->DidPrepareTiles();  // An explicit PrepareTiles.
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
-  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawIfPossible"));
   EXPECT_FALSE(client_->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // Next frame without DidPrepareTiles should PrepareTiles with draw.
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
-  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawIfPossible"));
   EXPECT_TRUE(client_->HasAction("ScheduledActionPrepareTiles"));
-  EXPECT_LT(client_->ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
+  EXPECT_LT(client_->ActionIndex("ScheduledActionDrawIfPossible"),
             client_->ActionIndex("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // If we get another DidPrepareTiles within the same frame, we should
   // not PrepareTiles on the next frame.
   scheduler_->WillPrepareTiles();
   scheduler_->DidPrepareTiles();  // An explicit PrepareTiles.
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
-  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawIfPossible"));
   EXPECT_FALSE(client_->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // If we get another DidPrepareTiles, we should not PrepareTiles on the next
   // frame. This verifies we don't alternate calling PrepareTiles once and
   // twice.
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
   scheduler_->WillPrepareTiles();
   scheduler_->DidPrepareTiles();  // An explicit PrepareTiles.
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
-  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawIfPossible"));
   EXPECT_FALSE(client_->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 
   // Next frame without DidPrepareTiles should PrepareTiles with draw.
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
-  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawIfPossible"));
   EXPECT_TRUE(client_->HasAction("ScheduledActionPrepareTiles"));
-  EXPECT_LT(client_->ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
+  EXPECT_LT(client_->ActionIndex("ScheduledActionDrawIfPossible"),
             client_->ActionIndex("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
 }
 
 TEST_F(SchedulerTest, PrepareTilesFunnelResetOnVisibilityChange) {
   std::unique_ptr<SchedulerClientNeedsPrepareTilesInDraw> client =
       base::WrapUnique(new SchedulerClientNeedsPrepareTilesInDraw);
   SetUpScheduler(EXTERNAL_BFS, std::move(client));
@@ skipping 14 matching lines @@
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
 
   client_->Reset();
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
 
   client_->Reset();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 2);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 1, 2);
 }
 
 TEST_F(SchedulerTest, TriggerBeginFrameDeadlineEarly) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
   SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
@@ skipping 32 matching lines @@
   client_->Reset();
   task_runner().RunPendingTasks();  // Try to run posted deadline.
   // There is no posted deadline.
   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"));
+  EXPECT_TRUE(client_->HasAction("ScheduledActionDrawIfPossible"));
 }
 
 TEST_F(SchedulerTest, WaitForReadyToDrawCancelledWhenLostCompositorFrameSink) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
   scheduler_settings_.commit_to_active_tree = true;
   SetUpScheduler(EXTERNAL_BFS, base::WrapUnique(client));
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
@@ skipping 239 matching lines @@
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->HasAction("WillBeginImplFrame"));
   EXPECT_TRUE(client_->HasAction("ScheduledActionSendBeginMainFrame"));
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
 }
 
-void SchedulerTest::ImplFrameSkippedAfterLateSwapAck(
-    bool swap_ack_before_deadline) {
+void SchedulerTest::ImplFrameSkippedAfterLateAck(

[sunnyps, 2016/10/14 01:08:47]

nit: Ack -> SubmitCompositorFrameAck

[danakj, 2016/10/14 01:19:31]

This makes test names go over 80 columns so I'll leave it for now?

+    bool receive_ack_before_deadline) {
   // To get into a high latency state, this test disables automatic swap acks.
-  client_->SetAutomaticSwapAck(false);
+  client_->SetAutomaticSubmitCompositorFrameAck(false);
 
   // Draw and swap for first BeginFrame
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   scheduler_->SetNeedsRedraw();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_ACTION("AddObserver(this)", client_, 0, 3);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 3);
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_ACTION("ScheduledActionCommit", client_, 0, 3);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 3);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 2, 3);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 2, 3);
 
   // Verify we skip every other frame if the swap ack consistently
   // comes back late.
   for (int i = 0; i < 10; i++) {
-    // Not calling scheduler_->DidSwapBuffersComplete() until after next
+    // Not calling scheduler_->DidReceiveCompositorFrameAck() until after next
     // BeginImplFrame puts the impl thread in high latency mode.
     client_->Reset();
     scheduler_->SetNeedsBeginMainFrame();
     scheduler_->SetNeedsRedraw();
     EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     // Verify that we skip the BeginImplFrame
     EXPECT_NO_ACTION(client_);
     EXPECT_FALSE(client_->IsInsideBeginImplFrame());
     EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
     // Verify that we do not perform any actions after we are no longer
     // swap throttled.
     client_->Reset();
-    if (swap_ack_before_deadline) {
+    if (receive_ack_before_deadline) {
       // It shouldn't matter if the swap ack comes back before the deadline...
-      scheduler_->DidSwapBuffersComplete();
+      scheduler_->DidReceiveCompositorFrameAck();
       task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
     } else {
       // ... or after the deadline.
       task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
-      scheduler_->DidSwapBuffersComplete();
+      scheduler_->DidReceiveCompositorFrameAck();
     }
     EXPECT_NO_ACTION(client_);
 
     // Verify that we start the next BeginImplFrame and continue normally
     // after having just skipped a BeginImplFrame.
     client_->Reset();
     EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
     EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
 
     client_->Reset();
     scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
     scheduler_->NotifyReadyToCommit();
     scheduler_->NotifyReadyToActivate();
     task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
     EXPECT_ACTION("ScheduledActionCommit", client_, 0, 3);
     EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 3);
-    EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 2, 3);
+    EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 2, 3);
   }
 }
 
 TEST_F(SchedulerTest,
-       ImplFrameSkippedAfterLateSwapAck_FastEstimates_SwapAckThenDeadline) {
+       ImplFrameSkippedAfterLateAck_FastEstimates_SubmitAckThenDeadline) {
   SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
-  bool swap_ack_before_deadline = true;
-  EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
+  bool receive_ack_before_deadline = true;
+  EXPECT_SCOPED(ImplFrameSkippedAfterLateAck(receive_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
-       ImplFrameSkippedAfterLateSwapAck_FastEstimates_DeadlineThenSwapAck) {
+       ImplFrameSkippedAfterLateAck_FastEstimates_DeadlineThenSubmitAck) {
   SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
-  bool swap_ack_before_deadline = false;
-  EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
+  bool receive_ack_before_deadline = false;
+  EXPECT_SCOPED(ImplFrameSkippedAfterLateAck(receive_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
-       ImplFrameSkippedAfterLateSwapAck_LongMainFrameQueueDurationNotCritical) {
+       ImplFrameSkippedAfterLateAck_LongMainFrameQueueDurationNotCritical) {
   SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
 
-  bool swap_ack_before_deadline = false;
-  EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
+  bool receive_ack_before_deadline = false;
+  EXPECT_SCOPED(ImplFrameSkippedAfterLateAck(receive_ack_before_deadline));
 }
 
-TEST_F(SchedulerTest,
-       ImplFrameSkippedAfterLateSwapAck_ImplLatencyTakesPriority) {
+TEST_F(SchedulerTest, ImplFrameSkippedAfterLateAck_ImplLatencyTakesPriority) {
   SetUpScheduler(EXTERNAL_BFS);
 
   // Even if every estimate related to the main thread is slow, we should
   // still expect to recover impl thread latency if the draw is fast and we
   // are in impl latency takes priority.
   scheduler_->SetTreePrioritiesAndScrollState(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER);
   fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
   fake_compositor_timing_history_->SetDrawDurationEstimate(kFastDuration);
 
-  bool swap_ack_before_deadline = false;
-  EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
+  bool receive_ack_before_deadline = false;
+  EXPECT_SCOPED(ImplFrameSkippedAfterLateAck(receive_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
-       ImplFrameSkippedAfterLateSwapAck_OnlyImplSideUpdatesExpected) {
+       ImplFrameSkippedAfterLateAck_OnlyImplSideUpdatesExpected) {
   // This tests that we recover impl thread latency when there are no commits.
   SetUpScheduler(EXTERNAL_BFS);
 
   // To get into a high latency state, this test disables automatic swap acks.
-  client_->SetAutomaticSwapAck(false);
+  client_->SetAutomaticSubmitCompositorFrameAck(false);
 
   // Even if every estimate related to the main thread is slow, we should
   // still expect to recover impl thread latency if there are no commits from
   // the main thread.
   fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
   fake_compositor_timing_history_->SetDrawDurationEstimate(kFastDuration);
 
   // Draw and swap for first BeginFrame
   client_->Reset();
   scheduler_->SetNeedsRedraw();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_ACTION("AddObserver(this)", client_, 0, 2);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 2);
 
   client_->Reset();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
-  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", client_);
 
   // Verify we skip every other frame if the swap ack consistently
   // comes back late.
   for (int i = 0; i < 10; i++) {
-    // Not calling scheduler_->DidSwapBuffersComplete() until after next
+    // Not calling scheduler_->DidReceiveCompositorFrameAck() until after next
     // BeginImplFrame puts the impl thread in high latency mode.
     client_->Reset();
     scheduler_->SetNeedsRedraw();
     EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     // Verify that we skip the BeginImplFrame
     EXPECT_NO_ACTION(client_);
     EXPECT_FALSE(client_->IsInsideBeginImplFrame());
     EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
     // Verify that we do not perform any actions after we are no longer
     // swap throttled.
     client_->Reset();
-    scheduler_->DidSwapBuffersComplete();
+    scheduler_->DidReceiveCompositorFrameAck();
     EXPECT_NO_ACTION(client_);
 
     // Verify that we start the next BeginImplFrame and continue normally
     // after having just skipped a BeginImplFrame.
     client_->Reset();
     EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
 
     client_->Reset();
     // Deadline should be immediate.
     EXPECT_TRUE(client_->IsInsideBeginImplFrame());
     task_runner().RunUntilTime(now_src_->NowTicks());
     EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-    EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+    EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", client_);
   }
 }
 
-void SchedulerTest::ImplFrameNotSkippedAfterLateSwapAck() {
+void SchedulerTest::ImplFrameNotSkippedAfterLateAck() {
   // To get into a high latency state, this test disables automatic swap acks.
-  client_->SetAutomaticSwapAck(false);
+  client_->SetAutomaticSubmitCompositorFrameAck(false);
 
   // Draw and swap for first BeginFrame
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_ACTION("AddObserver(this)", client_, 0, 3);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 3);
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_ACTION("ScheduledActionCommit", client_, 0, 3);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 3);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 2, 3);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 2, 3);
 
   // Verify impl thread consistently operates in high latency mode
   // without skipping any frames.
   for (int i = 0; i < 10; i++) {
-    // Not calling scheduler_->DidSwapBuffersComplete() until after next frame
+    // Not calling scheduler_->DidReceiveCompositorFrameAck() until after next
+    // frame
     // puts the impl thread in high latency mode.
     client_->Reset();
     scheduler_->SetNeedsBeginMainFrame();
     EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
     EXPECT_TRUE(client_->IsInsideBeginImplFrame());
     EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
     client_->Reset();
-    scheduler_->DidSwapBuffersComplete();
+    scheduler_->DidReceiveCompositorFrameAck();
     scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
     scheduler_->NotifyReadyToCommit();
     scheduler_->NotifyReadyToActivate();
     task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
 
     // Verify that we don't skip the actions of the BeginImplFrame
     EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 0, 4);
     EXPECT_ACTION("ScheduledActionCommit", client_, 1, 4);
     EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 2, 4);
-    EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 4);
+    EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 3, 4);
   }
 }
 
-TEST_F(
-    SchedulerTest,
-    ImplFrameNotSkippedAfterLateSwapAck_MainFrameQueueDurationCriticalTooLong) {
+TEST_F(SchedulerTest,
+       ImplFrameNotSkippedAfterLateAck_MainFrameQueueDurationCriticalTooLong) {
   SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameQueueDurationCriticalEstimate(kSlowDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
-  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
+  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateAck());
 }
 
-TEST_F(SchedulerTest,
-       ImplFrameNotSkippedAfterLateSwapAck_CommitEstimateTooLong) {
+TEST_F(SchedulerTest, ImplFrameNotSkippedAfterLateAck_CommitEstimateTooLong) {
   SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_
       ->SetBeginMainFrameStartToCommitDurationEstimate(kSlowDuration);
-  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
+  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateAck());
 }
 
 TEST_F(SchedulerTest,
-       ImplFrameNotSkippedAfterLateSwapAck_ReadyToActivateEstimateTooLong) {
+       ImplFrameNotSkippedAfterLateAck_ReadyToActivateEstimateTooLong) {
   SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetCommitToReadyToActivateDurationEstimate(
       kSlowDuration);
-  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
+  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateAck());
 }
 
-TEST_F(SchedulerTest,
-       ImplFrameNotSkippedAfterLateSwapAck_ActivateEstimateTooLong) {
+TEST_F(SchedulerTest, ImplFrameNotSkippedAfterLateAck_ActivateEstimateTooLong) {
   SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetActivateDurationEstimate(kSlowDuration);
-  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
+  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateAck());
 }
 
-TEST_F(SchedulerTest, ImplFrameNotSkippedAfterLateSwapAck_DrawEstimateTooLong) {
+TEST_F(SchedulerTest, ImplFrameNotSkippedAfterLateAck_DrawEstimateTooLong) {
   SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetDrawDurationEstimate(kSlowDuration);
-  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateSwapAck());
+  EXPECT_SCOPED(ImplFrameNotSkippedAfterLateAck());
 }
 
-TEST_F(SchedulerTest,
-       MainFrameThenImplFrameSkippedAfterLateCommitAndLateSwapAck) {
+TEST_F(SchedulerTest, MainFrameThenImplFrameSkippedAfterLateCommitAndLateAck) {
   // Set up client with custom estimates.
   // This test starts off with expensive estimates to prevent latency recovery
   // initially, then lowers the estimates to enable it once both the main
   // and impl threads are in a high latency mode.
   SetUpScheduler(EXTERNAL_BFS);
   fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
 
   // To get into a high latency state, this test disables automatic swap acks.
-  client_->SetAutomaticSwapAck(false);
+  client_->SetAutomaticSubmitCompositorFrameAck(false);
 
   // Impl thread hits deadline before commit finishes to make
   // MainThreadMissedLastDeadline true
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
@@ skipping 14 matching lines @@
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
 
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 5);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 5);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 2, 5);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 2, 5);
   EXPECT_ACTION("ScheduledActionCommit", client_, 3, 5);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 4, 5);
 
-  // Don't call scheduler_->DidSwapBuffersComplete() until after next frame
+  // Don't call scheduler_->DidReceiveCompositorFrameAck() until after next
+  // frame
   // to put the impl thread in a high latency mode.
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
 
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   // Note: BeginMainFrame and swap are skipped here because of
   // swap ack backpressure, not because of latency recovery.
   EXPECT_FALSE(client_->HasAction("ScheduledActionSendBeginMainFrame"));
-  EXPECT_FALSE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  EXPECT_FALSE(client_->HasAction("ScheduledActionDrawIfPossible"));
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
 
   // Lower estimates so that the scheduler will attempt latency recovery.
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   // Now that both threads are in a high latency mode, make sure we
   // skip the BeginMainFrame, then the BeginImplFrame, but not both
   // at the same time.
 
   // Verify we skip BeginMainFrame first.
   client_->Reset();
   // Previous commit request is still outstanding.
   EXPECT_TRUE(scheduler_->NeedsBeginMainFrame());
-  EXPECT_TRUE(scheduler_->SwapThrottled());
+  EXPECT_TRUE(scheduler_->IsDrawThrottled());
   SendNextBeginFrame();
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
-  scheduler_->DidSwapBuffersComplete();
+  scheduler_->DidReceiveCompositorFrameAck();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
 
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 1, 2);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 1, 2);
 
   // Verify we skip the BeginImplFrame second.
   client_->Reset();
   // Previous commit request is still outstanding.
   EXPECT_TRUE(scheduler_->NeedsBeginMainFrame());
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
-  scheduler_->DidSwapBuffersComplete();
+  scheduler_->DidReceiveCompositorFrameAck();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
   EXPECT_NO_ACTION(client_);
 
   // Then verify we operate in a low latency mode.
   client_->Reset();
   // Previous commit request is still outstanding.
   EXPECT_TRUE(scheduler_->NeedsBeginMainFrame());
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
-  scheduler_->DidSwapBuffersComplete();
+  scheduler_->DidReceiveCompositorFrameAck();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 5);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 5);
   EXPECT_ACTION("ScheduledActionCommit", client_, 2, 5);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 3, 5);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 4, 5);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 4, 5);
 }
 
 TEST_F(
     SchedulerTest,
     Deadlock_CommitMakesProgressWhileSwapTrottledAndActiveTreeNeedsFirstDraw) {
   // NPAPI plugins on Windows block the Browser UI thread on the Renderer main
   // thread. This prevents the scheduler from receiving any pending swap acks.
 
-  scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
+  scheduler_settings_.main_frame_while_submit_frame_throttled_enabled = true;
   SetUpScheduler(EXTERNAL_BFS);
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
-  client_->SetAutomaticSwapAck(false);
+  client_->SetAutomaticSubmitCompositorFrameAck(false);
 
   // Get a new active tree in main-thread high latency mode and put us
   // in a swap throttled state.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsBeginMainFrame();
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->CommitPending());
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
   EXPECT_FALSE(scheduler_->CommitPending());
   EXPECT_ACTION("AddObserver(this)", client_, 0, 6);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 6);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 6);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 6);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 3, 6);
   EXPECT_ACTION("ScheduledActionCommit", client_, 4, 6);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 5, 6);
 
   // Make sure that we can finish the next commit even while swap throttled.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SCOPED(AdvanceFrame());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
@@ skipping 17 matching lines @@
 }
 
 TEST_F(
     SchedulerTest,
     CommitMakesProgressWhenIdleAndHasPendingTreeAndActiveTreeNeedsFirstDraw) {
   // This verifies we don't block commits longer than we need to
   // for performance reasons - not deadlock reasons.
 
   // Since we are simulating a long commit, set up a client with draw duration
   // estimates that prevent skipping main frames to get to low latency mode.
-  scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
+  scheduler_settings_.main_frame_while_submit_frame_throttled_enabled = true;
   scheduler_settings_.main_frame_before_activation_enabled = true;
   SetUpScheduler(EXTERNAL_BFS);
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
-  client_->SetAutomaticSwapAck(false);
+  client_->SetAutomaticSubmitCompositorFrameAck(false);
 
   // Start a new commit in main-thread high latency mode and hold off on
   // activation.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsBeginMainFrame();
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->CommitPending());
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-  scheduler_->DidSwapBuffersComplete();
+  scheduler_->DidReceiveCompositorFrameAck();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_FALSE(scheduler_->CommitPending());
   EXPECT_ACTION("AddObserver(this)", client_, 0, 5);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 5);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 5);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 5);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 3, 5);
   EXPECT_ACTION("ScheduledActionCommit", client_, 4, 5);
 
   // Start another commit while we still have an active tree.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsBeginMainFrame();
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->CommitPending());
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-  scheduler_->DidSwapBuffersComplete();
+  scheduler_->DidReceiveCompositorFrameAck();
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 3);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 2, 3);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 2, 3);
 
   // Can't commit yet because there's still a pending tree.
   client_->Reset();
   scheduler_->NotifyReadyToCommit();
   EXPECT_NO_ACTION(client_);
 
   // Activate the pending tree, which also unblocks the commit immediately
   // while we are in an idle state.
   client_->Reset();
   scheduler_->NotifyReadyToActivate();
@@ skipping 30 matching lines @@
   client_->Reset();
 
   // NotifyReadyToActivate should trigger the activation.
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
   client_->Reset();
 
   // BeginImplFrame deadline should draw. The following BeginImplFrame deadline
   // should SetNeedsBeginFrame(false) to avoid excessive toggles.
   EXPECT_SCOPED(AdvanceFrame());
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 2);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 2);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 2);
   client_->Reset();
 
   // Make sure SetNeedsBeginFrame isn't called on the client
   // when the BeginFrame is no longer needed.
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("SendBeginMainFrameNotExpectedSoon", client_);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SyntheticBeginFrames) {
   BeginFramesNotFromClient(THROTTLED_BFS);
 }
 
 TEST_F(SchedulerTest, UnthrottledBeginFrames) {
   BeginFramesNotFromClient(UNTHROTTLED_BFS);
 }
 
-void SchedulerTest::BeginFramesNotFromClient_SwapThrottled(
+void SchedulerTest::BeginFramesNotFromClient_IsDrawThrottled(
     BeginFrameSourceType bfs_type) {
   SetUpScheduler(bfs_type);
 
   // Set the draw duration estimate to zero so that deadlines are accurate.
   fake_compositor_timing_history_->SetDrawDurationEstimate(base::TimeDelta());
 
   // To test swap ack throttling, this test disables automatic swap acks.
-  client_->SetAutomaticSwapAck(false);
+  client_->SetAutomaticSubmitCompositorFrameAck(false);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_NO_ACTION(client_);
   client_->Reset();
 
   // Trigger the first BeginImplFrame and BeginMainFrame
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // NotifyReadyToCommit should trigger the pending commit.
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   client_->Reset();
 
   // NotifyReadyToActivate should trigger the activation and draw.
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
   client_->Reset();
 
   // Swapping will put us into a swap throttled state.
   // Run posted deadline.
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // While swap throttled, BeginFrames should trigger BeginImplFrames,
   // but not a BeginMainFrame or draw.
   scheduler_->SetNeedsBeginMainFrame();
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());  // Run posted BeginFrame.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
@@ skipping 12 matching lines @@
             before_deadline + BeginFrameArgs::DefaultInterval());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());  // Run posted BeginFrame.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Take us out of a swap throttled state.
-  scheduler_->DidSwapBuffersComplete();
+  scheduler_->DidReceiveCompositorFrameAck();
   EXPECT_SINGLE_ACTION("ScheduledActionSendBeginMainFrame", client_);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // The deadline is set to the regular deadline.
   before_deadline = now_src()->NowTicks();
   task_runner().RunTasksWhile(client_->InsideBeginImplFrame(true));
   after_deadline = now_src()->NowTicks();
   // We can't do an equality comparison here because the scheduler uses a fudge
   // factor that's an internal implementation detail.
   EXPECT_GT(after_deadline, before_deadline);
   EXPECT_LT(after_deadline,
             before_deadline + BeginFrameArgs::DefaultInterval());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
-TEST_F(SchedulerTest, SyntheticBeginFrames_SwapThrottled) {
-  BeginFramesNotFromClient_SwapThrottled(THROTTLED_BFS);
+TEST_F(SchedulerTest, SyntheticBeginFrames_IsDrawThrottled) {
+  BeginFramesNotFromClient_IsDrawThrottled(THROTTLED_BFS);
 }
 
-TEST_F(SchedulerTest, UnthrottledBeginFrames_SwapThrottled) {
-  BeginFramesNotFromClient_SwapThrottled(UNTHROTTLED_BFS);
+TEST_F(SchedulerTest, UnthrottledBeginFrames_IsDrawThrottled) {
+  BeginFramesNotFromClient_IsDrawThrottled(UNTHROTTLED_BFS);
 }
 
 TEST_F(SchedulerTest,
        DidLoseCompositorFrameSinkAfterCompositorFrameSinkIsInitialized) {
   SetUpSchedulerWithNoCompositorFrameSink(EXTERNAL_BFS);
 
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginCompositorFrameSinkCreation",
@@ skipping 203 matching lines @@
   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);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
 
   // Idle time between BeginFrames.
   client_->Reset();
   scheduler_->DidLoseCompositorFrameSink();
   EXPECT_ACTION("ScheduledActionBeginCompositorFrameSinkCreation", client_, 0,
                 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
@@ skipping 61 matching lines @@
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   scheduler_->SetNeedsRedraw();
 
   // Switch to an unthrottled frame source.
   scheduler_->SetBeginFrameSource(unthrottled_frame_source_.get());
   client_->Reset();
 
   // Unthrottled frame source will immediately begin a new frame.
   task_runner().RunPendingTasks();  // Run posted BeginFrame.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // If we don't swap on the deadline, we wait for the next BeginFrame.
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 // Tests to ensure frame sources can be successfully changed while a frame
 // deadline is pending.
 TEST_F(SchedulerTest, SwitchFrameSourceToUnthrottledBeforeDeadline) {
   SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsRedraw should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
 
   // Switch to an unthrottled frame source before the frame deadline is hit.
   scheduler_->SetBeginFrameSource(unthrottled_frame_source_.get());
   client_->Reset();
 
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 2);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 2);
   // Unthrottled frame source will immediately begin a new frame.
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 2);
   scheduler_->SetNeedsRedraw();
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 // Tests to ensure that the active frame source can successfully be changed from
 // unthrottled to throttled.
 TEST_F(SchedulerTest, SwitchFrameSourceToThrottled) {
   SetUpScheduler(UNTHROTTLED_BFS);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_NO_ACTION(client_);
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted BeginFrame.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Switch to a throttled frame source.
   scheduler_->SetBeginFrameSource(fake_external_begin_frame_source_.get());
   client_->Reset();
 
   // SetNeedsRedraw should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsRedraw();
   task_runner().RunPendingTasks();
   EXPECT_NO_ACTION(client_);
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
 }
 
 TEST_F(SchedulerTest, SwitchFrameSourceToNullInsideDeadline) {
   SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
   client_->Reset();
 
   // Switch to a null frame source.
   scheduler_->SetBeginFrameSource(nullptr);
   EXPECT_SINGLE_ACTION("RemoveObserver(this)", client_);
   client_->Reset();
 
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(scheduler_->begin_frames_expected());
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // AdvanceFrame helper can't be used here because there's no deadline posted.
   scheduler_->SetNeedsRedraw();
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_NO_ACTION(client_);
   client_->Reset();
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_NO_ACTION(client_);
   client_->Reset();
 
   // Switch back to the same source, make sure frames continue to be produced.
   scheduler_->SetBeginFrameSource(fake_external_begin_frame_source_.get());
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   task_runner().RunPendingTasks();
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
 }
 
 // This test maskes sure that switching a frame source when not observing
 // such as when not visible also works.
 TEST_F(SchedulerTest, SwitchFrameSourceWhenNotObserving) {
   SetUpScheduler(EXTERNAL_BFS);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
@@ skipping 56 matching lines @@
   // Trigger a frame draw.
   EXPECT_SCOPED(AdvanceFrame());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
   task_runner().RunPendingTasks();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 5);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 5);
   EXPECT_ACTION("ScheduledActionCommit", client_, 2, 5);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 3, 5);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 4, 5);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 4, 5);
   client_->Reset();
 
   // The following BeginImplFrame deadline should SetNeedsBeginFrame(false)
   // and send a SendBeginMainFrameNotExpectedSoon.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
@@ skipping 19 matching lines @@
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 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_->OnDrawForCompositorFrameSink(resourceless_software_draw);
-  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", 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("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
-  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", 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;
   SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_ACTION("AddObserver(this)", client_, 0, 2);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 1, 2);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", 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);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
@@ skipping 72 matching lines @@
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
-  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", 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());
   client_->Reset();
@@ skipping 42 matching lines @@
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   client_->Reset();
 }
 
 class SchedulerClientSetNeedsPrepareTilesOnDraw : public FakeSchedulerClient {
  public:
   SchedulerClientSetNeedsPrepareTilesOnDraw() : FakeSchedulerClient() {}
 
  protected:
-  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
+  DrawResult ScheduledActionDrawIfPossible() override {
     scheduler_->SetNeedsPrepareTiles();
-    return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
+    return FakeSchedulerClient::ScheduledActionDrawIfPossible();
   }
 };
 
 TEST_F(SchedulerTest, SynchronousCompositorPrepareTilesOnDraw) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
 
   std::unique_ptr<FakeSchedulerClient> client =
       base::WrapUnique(new SchedulerClientSetNeedsPrepareTilesOnDraw);
   SetUpScheduler(EXTERNAL_BFS, std::move(client));
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Next vsync.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 2);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 2);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", 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);
@@ skipping 13 matching lines @@
   // Next vsync.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
-  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", 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("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 2);
   client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
-  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", 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;
   SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetVisible(false);
 
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = true;
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   // SynchronousCompositor has to draw regardless of visibility.
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
+  EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, AuthoritativeVSyncInterval) {
   SetUpScheduler(THROTTLED_BFS);
   base::TimeDelta initial_interval = scheduler_->BeginImplFrameInterval();
   base::TimeDelta authoritative_interval =
       base::TimeDelta::FromMilliseconds(33);
 
@@ skipping 182 matching lines @@
 }
 
 TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_AHS) {
   EXPECT_FALSE(BeginMainFrameOnCriticalPath(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER, kSlowDuration));
 }
 
 }  // namespace
 }  // namespace cc