cc: Throttle swaps in Scheduler instead of OutputSurface

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 <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 22 matching lines @@
 namespace {
 
 class FakeSchedulerClient;
 
 void InitializeOutputSurfaceAndFirstCommit(Scheduler* scheduler,
                                            FakeSchedulerClient* client);
 
 class FakeSchedulerClient : public SchedulerClient {
  public:
   FakeSchedulerClient()
-  : needs_begin_impl_frame_(false) {
+      : needs_begin_impl_frame_(false), automatic_swap_ack_(true) {
     Reset();
   }
 
   void Reset() {
     actions_.clear();
     states_.clear();
     draw_will_happen_ = true;
     swap_will_happen_if_draw_happens_ = true;
     num_draws_ = 0;
     log_anticipated_draw_time_change_ = false;
@@ skipping 31 matching lines @@
   bool HasAction(const char* action) const {
     return ActionIndex(action) >= 0;
   }
 
   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;
+  }
 
   // SchedulerClient implementation.
   virtual void SetNeedsBeginFrame(bool enable) OVERRIDE {
     actions_.push_back("SetNeedsBeginFrame");
     states_.push_back(scheduler_->StateAsValue().release());
     needs_begin_impl_frame_ = enable;
   }
   virtual void WillBeginImplFrame(const BeginFrameArgs& args) OVERRIDE {
     actions_.push_back("WillBeginImplFrame");
     states_.push_back(scheduler_->StateAsValue().release());
   }
   virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {
     actions_.push_back("ScheduledActionSendBeginMainFrame");
     states_.push_back(scheduler_->StateAsValue().release());
   }
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
       OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapIfPossible");
     states_.push_back(scheduler_->StateAsValue().release());
     num_draws_++;
     bool did_readback = false;
     DrawSwapReadbackResult::DrawResult result =
         draw_will_happen_
             ? DrawSwapReadbackResult::DRAW_SUCCESS
             : DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
+    bool swap_will_happen =
+        draw_will_happen_ && swap_will_happen_if_draw_happens_;
+    if (swap_will_happen) {
+      scheduler_->DidSwapBuffers();
+      if (automatic_swap_ack_)
+        scheduler_->DidSwapBuffersComplete();
+    }
     return DrawSwapReadbackResult(
         result,
         draw_will_happen_ && swap_will_happen_if_draw_happens_,
         did_readback);
   }
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapForced");
     states_.push_back(scheduler_->StateAsValue().release());
-    bool did_swap = swap_will_happen_if_draw_happens_;
+    bool did_request_swap = swap_will_happen_if_draw_happens_;
     bool did_readback = false;
     return DrawSwapReadbackResult(
-        DrawSwapReadbackResult::DRAW_SUCCESS, did_swap, did_readback);
+        DrawSwapReadbackResult::DRAW_SUCCESS, did_request_swap, did_readback);
   }
   virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndReadback");
     states_.push_back(scheduler_->StateAsValue().release());
-    bool did_swap = false;
+    bool did_request_swap = false;
     bool did_readback = true;
     return DrawSwapReadbackResult(
-        DrawSwapReadbackResult::DRAW_SUCCESS, did_swap, did_readback);
+        DrawSwapReadbackResult::DRAW_SUCCESS, did_request_swap, did_readback);
   }
   virtual void ScheduledActionCommit() OVERRIDE {
     actions_.push_back("ScheduledActionCommit");
     states_.push_back(scheduler_->StateAsValue().release());
   }
   virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE {
     actions_.push_back("ScheduledActionUpdateVisibleTiles");
     states_.push_back(scheduler_->StateAsValue().release());
   }
   virtual void ScheduledActionActivatePendingTree() OVERRIDE {
@@ skipping 21 matching lines @@
   virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
 
   virtual void DidBeginImplFrameDeadline() OVERRIDE {}
 
  protected:
   bool needs_begin_impl_frame_;
   bool draw_will_happen_;
   bool swap_will_happen_if_draw_happens_;
+  bool automatic_swap_ack_;
   int num_draws_;
   bool log_anticipated_draw_time_change_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   ScopedVector<base::Value> states_;
   scoped_ptr<Scheduler> scheduler_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
 };
 
 void InitializeOutputSurfaceAndFirstCommit(Scheduler* scheduler,
@@ skipping 183 matching lines @@
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
       OVERRIDE {
     // Only SetNeedsRedraw the first time this is called
     if (!num_draws_)
       scheduler_->SetNeedsRedraw();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     NOTREACHED();
-    bool did_swap = true;
+    bool did_request_swap = true;
     bool did_readback = false;
     return DrawSwapReadbackResult(
-        DrawSwapReadbackResult::DRAW_SUCCESS, did_swap, did_readback);
+        DrawSwapReadbackResult::DRAW_SUCCESS, did_request_swap, did_readback);
   }
 
   virtual void ScheduledActionCommit() OVERRIDE {}
   virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {}
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
 };
 
 // Tests for two different situations:
 // 1. the scheduler dropping SetNeedsRedraw requests that happen inside
 //    a ScheduledActionDrawAndSwap
@@ skipping 92 matching lines @@
     // Only SetNeedsCommit the first time this is called
     if (set_needs_commit_on_next_draw_) {
       scheduler_->SetNeedsCommit();
       set_needs_commit_on_next_draw_ = false;
     }
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     NOTREACHED();
-    bool did_swap = false;
+    bool did_request_swap = false;
     bool did_readback = false;
     return DrawSwapReadbackResult(
-        DrawSwapReadbackResult::DRAW_SUCCESS, did_swap, did_readback);
+        DrawSwapReadbackResult::DRAW_SUCCESS, did_request_swap, did_readback);
   }
 
   virtual void ScheduledActionCommit() OVERRIDE {}
   virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {}
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
 
   void SetNeedsCommitOnNextDraw() { set_needs_commit_on_next_draw_ = true; }
 
  private:
   bool set_needs_commit_on_next_draw_;
@@ skipping 537 matching lines @@
   scheduler->SetNeedsRedraw();
 
   BeginFrameArgs frame_args = BeginFrameArgs::CreateForTesting();
   frame_args.interval = base::TimeDelta::FromMilliseconds(1000);
   scheduler->BeginFrame(frame_args);
 
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
 
+  scheduler->DidSwapBuffers();
+  scheduler->DidSwapBuffersComplete();
+
   // At this point, we've drawn a frame. Start another commit, but hold off on
   // the NotifyReadyToCommit for now.
   EXPECT_FALSE(scheduler->CommitPending());
   scheduler->SetNeedsCommit();
   scheduler->BeginFrame(frame_args);
   EXPECT_TRUE(scheduler->CommitPending());
 
+  // Draw and swap the frame, but don't ack the swap to simulate the Browser
+  // blocking on the renderer.
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  client.task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
+  scheduler->DidSwapBuffers();
+
   // Spin the event loop a few times and make sure we get more
   // DidAnticipateDrawTimeChange calls every time.
   int actions_so_far = client.num_actions_();
 
   // Does three iterations to make sure that the timer is properly repeating.
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ((frame_args.interval * 2).InMicroseconds(),
               client.task_runner().NextPendingTaskDelay().InMicroseconds())
         << *scheduler->StateAsValue();
     client.task_runner().RunPendingTasks();
@@ skipping 10 matching lines @@
               client.task_runner().NextPendingTaskDelay().InMicroseconds())
         << *scheduler->StateAsValue();
     client.task_runner().RunPendingTasks();
     EXPECT_GT(client.num_actions_(), actions_so_far);
     EXPECT_STREQ(client.Action(client.num_actions_() - 1),
                  "DidAnticipatedDrawTimeChange");
     actions_so_far = client.num_actions_();
   }
 }
 
-TEST(SchedulerTest, BeginRetroFrame) {
+TEST(SchedulerTest, BeginRetroFrameBasic) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
 
   // SetNeedsCommit should begin the frame on the next BeginImplFrame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(client.needs_begin_impl_frame());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
   client.Reset();
 
   // Create a BeginFrame with a long deadline to avoid race conditions.
   // This is the first BeginFrame, which will be handled immediately.
   BeginFrameArgs args = BeginFrameArgs::CreateForTesting();
   args.deadline += base::TimeDelta::FromHours(1);
   scheduler->BeginFrame(args);
-
   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // Queue BeginFrames while we are still handling the previous BeginFrame.
   args.frame_time += base::TimeDelta::FromSeconds(1);
   scheduler->BeginFrame(args);
   args.frame_time += base::TimeDelta::FromSeconds(1);
@@ skipping 35 matching lines @@
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
   client.Reset();
 
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
   EXPECT_FALSE(client.needs_begin_impl_frame());
   client.Reset();
 }
 
+TEST(SchedulerTest, BeginRetroFrame_SwapThrottled) {
+  FakeSchedulerClient client;
+  SchedulerSettings scheduler_settings;
+  Scheduler* scheduler = client.CreateScheduler(scheduler_settings);
+  scheduler->SetCanStart();
+  scheduler->SetVisible(true);
+  scheduler->SetCanDraw(true);
+  InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
+
+  // To test swap ack throttling, this test disables automatic swap acks.
+  scheduler->SetMaxSwapsPending(1);
+  client.SetAutomaticSwapAck(false);
+
+  // SetNeedsCommit should begin the frame on the next BeginImplFrame.
+  client.Reset();
+  scheduler->SetNeedsCommit();
+  EXPECT_TRUE(client.needs_begin_impl_frame());
+  EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
+  client.Reset();
+
+  // Create a BeginFrame with a long deadline to avoid race conditions.
+  // This is the first BeginFrame, which will be handled immediately.
+  BeginFrameArgs args = BeginFrameArgs::CreateForTesting();
+  args.deadline += base::TimeDelta::FromHours(1);
+  scheduler->BeginFrame(args);
+  EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
+  EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  EXPECT_TRUE(client.needs_begin_impl_frame());
+  client.Reset();
+
+  // Queue BeginFrame while we are still handling the previous BeginFrame.
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  args.frame_time += base::TimeDelta::FromSeconds(1);
+  scheduler->BeginFrame(args);
+  EXPECT_EQ(0, client.num_actions_());
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  client.Reset();
+
+  // NotifyReadyToCommit should trigger the pending commit and draw.
+  scheduler->NotifyBeginMainFrameStarted();
+  scheduler->NotifyReadyToCommit();
+  EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
+  EXPECT_TRUE(client.needs_begin_impl_frame());
+  client.Reset();
+
+  // Swapping will put us into a swap throttled state.
+  client.task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
+  EXPECT_ACTION("SetNeedsBeginFrame", client, 1, 2);
+  EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
+  EXPECT_TRUE(client.needs_begin_impl_frame());
+  client.Reset();
+
+  // While swap throttled, BeginRetroFrames should trigger BeginImplFrames
+  // but not a BeginMainFrame or draw.
+  scheduler->SetNeedsCommit();
+  client.task_runner().RunPendingTasks();  // Run posted BeginRetroFrame.
+  EXPECT_ACTION("WillBeginImplFrame", client, 0, 1);
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  EXPECT_TRUE(client.needs_begin_impl_frame());
+  client.Reset();
+
+  // Queue BeginFrame while we are still handling the previous BeginFrame.
+  args.frame_time += base::TimeDelta::FromSeconds(1);
+  scheduler->BeginFrame(args);
+  EXPECT_EQ(0, client.num_actions_());
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  EXPECT_TRUE(client.needs_begin_impl_frame());
+  client.Reset();
+
+  // Take us out of a swap throttled state.
+  scheduler->DidSwapBuffersComplete();
+  EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 1);
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  EXPECT_TRUE(client.needs_begin_impl_frame());
+  client.Reset();
+
+  // BeginImplFrame deadline should draw.
+  scheduler->SetNeedsRedraw();
+  client.task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
+  EXPECT_ACTION("SetNeedsBeginFrame", client, 1, 2);
+  EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
+  EXPECT_TRUE(client.needs_begin_impl_frame());
+  client.Reset();
+}
+
 }  // namespace
 }  // namespace cc