cc: Use BeginFrameArgs

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 "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define EXPECT_ACTION(action, client, action_index, expected_num_actions) \
   EXPECT_EQ(expected_num_actions, client.num_actions_());                 \
   ASSERT_LT(action_index, client.num_actions_());                         \
   do {                                                                    \
     EXPECT_STREQ(action, client.Action(action_index));                    \
     for (int i = expected_num_actions; i < client.num_actions_(); ++i)    \
       ADD_FAILURE() << "Unexpected action: " << client.Action(i) <<       \
           " with state:\n" << client.StateForAction(action_index);        \
   } while (false)
 
 #define EXPECT_SINGLE_ACTION(action, client) \
   EXPECT_ACTION(action, client, 0, 1)
 
 namespace cc {
 namespace {
 
+void InitializeOutputSurfaceAndFirstCommit(Scheduler* scheduler) {
+  scheduler->DidCreateAndInitializeOutputSurface();
+  scheduler->SetNeedsCommit();
+  scheduler->FinishCommit();
+  scheduler->SetHasTrees(0, 0);
+  // Go through the motions to draw the commit.
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
+  // We need another BeginFrame so scheduler calls SetNeedsBeginFrame(false).
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
+}
+
 class FakeSchedulerClient : public SchedulerClient {
  public:
   FakeSchedulerClient()
   : needs_begin_frame_(false) {
     Reset();
   }
 
   void Reset() {
     actions_.clear();
     states_.clear();
@@ skipping 30 matching lines @@
   // Scheduler Implementation.
   virtual void SetNeedsBeginFrameOnImplThread(bool enable) OVERRIDE {
     actions_.push_back("SetNeedsBeginFrameOnImplThread");
     states_.push_back(scheduler_->StateAsStringForTesting());
     needs_begin_frame_ = enable;
   }
   virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {
     actions_.push_back("ScheduledActionSendBeginFrameToMainThread");
     states_.push_back(scheduler_->StateAsStringForTesting());
   }
-  virtual ScheduledActionDrawAndSwapResult
-  ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
+      OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapIfPossible");
     states_.push_back(scheduler_->StateAsStringForTesting());
     num_draws_++;
-    return ScheduledActionDrawAndSwapResult(draw_will_happen_,
-                                            draw_will_happen_ &&
-                                            swap_will_happen_if_draw_happens_);
+    return DrawSwapReadbackResult(
+        draw_will_happen_,
+        draw_will_happen_ && swap_will_happen_if_draw_happens_,
+        false);
   }
-  virtual ScheduledActionDrawAndSwapResult ScheduledActionDrawAndSwapForced()
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced()
       OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapForced");
     states_.push_back(scheduler_->StateAsStringForTesting());
-    return ScheduledActionDrawAndSwapResult(true,
-                                            swap_will_happen_if_draw_happens_);
+    return DrawSwapReadbackResult(
+        true, swap_will_happen_if_draw_happens_, false);
+  }
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback()
+      OVERRIDE {
+    actions_.push_back("ScheduledActionDrawAndReadback");
+    states_.push_back(scheduler_->StateAsStringForTesting());
+    return DrawSwapReadbackResult(true, false, true);
   }
   virtual void ScheduledActionCommit() OVERRIDE {
     actions_.push_back("ScheduledActionCommit");
     states_.push_back(scheduler_->StateAsStringForTesting());
   }
   virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE {
     actions_.push_back("ScheduledActionUpdateVisibleTiles");
     states_.push_back(scheduler_->StateAsStringForTesting());
   }
-  virtual void ScheduledActionActivatePendingTreeIfNeeded() OVERRIDE {
-    actions_.push_back("ScheduledActionActivatePendingTreeIfNeeded");
+  virtual void ScheduledActionActivatePendingTree() OVERRIDE {
+    actions_.push_back("ScheduledActionActivatePendingTree");
     states_.push_back(scheduler_->StateAsStringForTesting());
   }
   virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {
     actions_.push_back("ScheduledActionBeginOutputSurfaceCreation");
     states_.push_back(scheduler_->StateAsStringForTesting());
   }
   virtual void ScheduledActionAcquireLayerTexturesForMainThread() OVERRIDE {
     actions_.push_back("ScheduledActionAcquireLayerTexturesForMainThread");
     states_.push_back(scheduler_->StateAsStringForTesting());
   }
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {}
   virtual base::TimeDelta DrawDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
   virtual base::TimeDelta BeginFrameToCommitDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
   virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
 
+  virtual void PostBeginFrameDeadline(const base::Closure& closure,
+                                      base::TimeTicks deadline) OVERRIDE {
+    actions_.push_back("PostBeginFrameDeadlineTask");
+    states_.push_back(scheduler_->StateAsStringForTesting());
+  }
+
+  virtual void DidBeginFrameDeadlineOnImplThread() OVERRIDE {
+  }
+
  protected:
   bool needs_begin_frame_;
   bool draw_will_happen_;
   bool swap_will_happen_if_draw_happens_;
   int num_draws_;
   std::vector<const char*> actions_;
   std::vector<std::string> states_;
   scoped_ptr<Scheduler> scheduler_;
 };
 
@@ skipping 13 matching lines @@
 
 TEST(SchedulerTest, RequestCommit) {
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
+
+  // SetNeedsCommit should begin the frame on the next BeginFrame.
   client.Reset();
-  scheduler->DidCreateAndInitializeOutputSurface();
+  scheduler->SetNeedsCommit();
+  EXPECT_TRUE(client.needs_begin_frame());
+  client.Reset();
 
-  // SetNeedsCommit should begin the frame.
-  scheduler->SetNeedsCommit();
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
+  EXPECT_TRUE(client.needs_begin_frame());
+  client.Reset();
+
+  // If we don't swap on the deadline, we need to request another BeginFrame.
+  scheduler->OnBeginFrameDeadline();
+  EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client);
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // FinishCommit should commit
   scheduler->FinishCommit();
-  EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
+  EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
-  // BeginFrame should draw.
+  // BeginFrame should prepare the draw.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
+  EXPECT_SINGLE_ACTION("PostBeginFrameDeadlineTask", client);
+  EXPECT_TRUE(client.needs_begin_frame());
+  client.Reset();
+
+  // BeginFrame deadline should draw.
+  scheduler->OnBeginFrameDeadline();
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client);
+  client.Reset();
+
+  // The following BeginFrame deadline should SetNeedsBeginFrame(false) to avoid
+  // excessive toggles.
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  EXPECT_SINGLE_ACTION("PostBeginFrameDeadlineTask", client);
+  client.Reset();
+
+  scheduler->OnBeginFrameDeadline();
+  EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client);
   EXPECT_FALSE(client.needs_begin_frame());
   client.Reset();
 }
 
 TEST(SchedulerTest, RequestCommitAfterBeginFrameSentToMainThread) {
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
-  client.Reset();
-  scheduler->DidCreateAndInitializeOutputSurface();
-
-  // SetNedsCommit should begin the frame.
-  scheduler->SetNeedsCommit();
-  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
   client.Reset();
 
-  // Now SetNeedsCommit again. Calling here means we need a second frame.
+  // SetNeddsCommit should begin the frame.
   scheduler->SetNeedsCommit();
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 0, 1);
+  EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client);
+  client.Reset();
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
+  EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
-  // Since another commit is needed, FinishCommit should commit,
-  // then begin another frame.
+  // Now SetNeedsCommit again. Calling here means we need a second commit.
+  scheduler->SetNeedsCommit();
+  EXPECT_EQ(client.num_actions_(), 0);
+  client.Reset();
+
+  // Finish the first commit.
   scheduler->FinishCommit();
   EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
+  client.Reset();
+  scheduler->OnBeginFrameDeadline();
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client);
   client.Reset();
 
-  // Tick should draw but then begin another frame.
+  // Since another commit is needed, the next BeginFrame should initiate
+  // the second commit.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
-  EXPECT_TRUE(client.needs_begin_frame());
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
-  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 1, 2);
+  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
   client.Reset();
 
-  // Go back to quiescent state and verify we no longer request BeginFrames.
+  // Finishing the commit before the deadline should post a new deadline task
+  // to trigger the deadline early.
   scheduler->FinishCommit();
+  EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
+  client.Reset();
+  scheduler->OnBeginFrameDeadline();
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client);
+  EXPECT_TRUE(client.needs_begin_frame());
+
+  // On the next BeginFrame, go back to quiescent state and verify we no longer
+  // request BeginFrames.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_FALSE(client.needs_begin_frame());
+  client.Reset();
 }
 
 TEST(SchedulerTest, TextureAcquisitionCausesCommitInsteadOfDraw) {
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
 
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
   client.Reset();
-  scheduler->DidCreateAndInitializeOutputSurface();
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client);
   EXPECT_TRUE(client.needs_begin_frame());
 
   client.Reset();
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
+  EXPECT_SINGLE_ACTION("PostBeginFrameDeadlineTask", client);
+
+  client.Reset();
+  scheduler->OnBeginFrameDeadline();
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client);
   EXPECT_FALSE(scheduler->RedrawPending());
-  EXPECT_FALSE(client.needs_begin_frame());
 
   client.Reset();
   scheduler->SetMainThreadNeedsLayerTextures();
   EXPECT_SINGLE_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                        client);
 
   // We should request a BeginFrame in anticipation of a draw.
   client.Reset();
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client);
-  EXPECT_TRUE(client.needs_begin_frame());
+  EXPECT_EQ(0, client.num_actions_());
 
   // No draw happens since the textures are acquired by the main thread.
   client.Reset();
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  EXPECT_SINGLE_ACTION("PostBeginFrameDeadlineTask", client);
+
+  client.Reset();
+  scheduler->OnBeginFrameDeadline();
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client);
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
+  client.Reset();
   scheduler->SetNeedsCommit();
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 0, 2);
-  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 1, 2);
-  EXPECT_TRUE(client.needs_begin_frame());
+  EXPECT_EQ(0, client.num_actions_());
+
+  client.Reset();
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
 
   // Commit will release the texture.
   client.Reset();
   scheduler->FinishCommit();
-  EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
+  EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(client.needs_begin_frame());
 
   // Now we can draw again after the commit happens.
   client.Reset();
+  scheduler->OnBeginFrameDeadline();
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client);
+  EXPECT_FALSE(scheduler->RedrawPending());
+
+  // SetNeedsBeginFrame(false) should be deferred to the end of the next
+  // BeginFrame to avoid excessive toggling.
+  EXPECT_TRUE(client.needs_begin_frame());
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
-  EXPECT_FALSE(scheduler->RedrawPending());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_FALSE(client.needs_begin_frame());
-  client.Reset();
 }
 
 TEST(SchedulerTest, TextureAcquisitionCollision) {
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
+
   client.Reset();
-  scheduler->DidCreateAndInitializeOutputSurface();
-
   scheduler->SetNeedsCommit();
   scheduler->SetMainThreadNeedsLayerTextures();
-  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 4);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 4);
+  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                 client,
-                2,
-                4);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 3, 4);
+                1,
+                2);
+
   client.Reset();
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
+
+  client.Reset();
+  scheduler->OnBeginFrameDeadline();
+  EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client);
 
   // Although the compositor cannot draw because textures are locked by main
   // thread, we continue requesting SetNeedsBeginFrame in anticipation of the
   // unlock.
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Trigger the commit
   scheduler->FinishCommit();
   EXPECT_TRUE(client.needs_begin_frame());
-  client.Reset();
 
   // Between commit and draw, texture acquisition for main thread delayed,
   // and main thread blocks.
+  client.Reset();
   scheduler->SetMainThreadNeedsLayerTextures();
   EXPECT_EQ(0, client.num_actions_());
-  client.Reset();
 
   // No implicit commit is expected.
+  client.Reset();
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
-  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 3);
+  EXPECT_SINGLE_ACTION("PostBeginFrameDeadlineTask", client);
+
+  client.Reset();
+  scheduler->OnBeginFrameDeadline();
+  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                 client,
                 1,
-                3);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 2, 3);
-  client.Reset();
+                2);
 
-  // Compositor not scheduled to draw because textures are locked by main
-  // thread.
-  EXPECT_FALSE(client.needs_begin_frame());
+  // Although the compositor is not scheduled to draw because textures are
+  // locked by main thread, we proactively request the begin frame.
+  EXPECT_TRUE(client.needs_begin_frame());
 
   // Needs an explicit commit from the main thread.
+  client.Reset();
   scheduler->SetNeedsCommit();
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
   client.Reset();
 
   // Trigger the commit
   scheduler->FinishCommit();
   EXPECT_TRUE(client.needs_begin_frame());
 }
 
 TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition) {
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   client.Reset();
   scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsCommit();
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   scheduler->FinishCommit();
   scheduler->SetMainThreadNeedsLayerTextures();
   scheduler->SetNeedsCommit();
   client.Reset();
   // Verify that pending texture acquisition fires when visibility
   // is lost in order to avoid a deadlock.
   scheduler->SetVisible(false);
   EXPECT_SINGLE_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                        client);
-  client.Reset();
 
   // Already sent a begin frame on this current frame, so wait.
+  client.Reset();
   scheduler->SetVisible(true);
   EXPECT_EQ(0, client.num_actions_());
-  client.Reset();
+  EXPECT_TRUE(client.needs_begin_frame());
 
   // Regaining visibility with textures acquired by main thread while
   // compositor is waiting for first draw should result in a request
   // for a new frame in order to escape a deadlock.
+  client.Reset();
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
+  EXPECT_ACTION("PostBeginFrameDeadlineTask", client, 1, 2);
 }
 
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
   virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {}
-  virtual ScheduledActionDrawAndSwapResult
+  virtual DrawSwapReadbackResult
   ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
     // Only SetNeedsRedraw the first time this is called
     if (!num_draws_)
       scheduler_->SetNeedsRedraw();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
-  virtual ScheduledActionDrawAndSwapResult ScheduledActionDrawAndSwapForced()
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced()
       OVERRIDE {
     NOTREACHED();
-    return ScheduledActionDrawAndSwapResult(true, true);
+    return DrawSwapReadbackResult(true, true, false);
   }
 
   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
 // 2. the scheduler drawing twice inside a single tick
 TEST(SchedulerTest, RequestRedrawInsideDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
-  scheduler->DidCreateAndInitializeOutputSurface();
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
+  client.Reset();
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
 
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_FALSE(scheduler->RedrawPending());
+  EXPECT_TRUE(client.needs_begin_frame());
+
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_FALSE(client.needs_begin_frame());
 }
 
 // Test that requesting redraw inside a failed draw doesn't lose the request.
 TEST(SchedulerTest, RequestRedrawInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
-  scheduler->DidCreateAndInitializeOutputSurface();
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
+  client.Reset();
 
   client.SetDrawWillHappen(false);
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
 
   // Fail the draw.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(1, client.num_draws());
 
   // We have a commit pending and the draw failed, and we didn't lose the redraw
   // request.
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Fail the draw again.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Draw successfully.
   client.SetDrawWillHappen(true);
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(3, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 }
 
-class SchedulerClientThatsetNeedsCommitInsideDraw : public FakeSchedulerClient {
+class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
  public:
+  SchedulerClientThatSetNeedsCommitInsideDraw()
+  : set_needs_commit_on_next_draw_(false) {}
+
   virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {}
-  virtual ScheduledActionDrawAndSwapResult
+  virtual DrawSwapReadbackResult
   ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
     // Only SetNeedsCommit the first time this is called
-    if (!num_draws_)
+    if (set_needs_commit_on_next_draw_) {
       scheduler_->SetNeedsCommit();
+      set_needs_commit_on_next_draw_ = false;
+    }
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
-  virtual ScheduledActionDrawAndSwapResult ScheduledActionDrawAndSwapForced()
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced()
       OVERRIDE {
     NOTREACHED();
-    return ScheduledActionDrawAndSwapResult(true, true);
+    return DrawSwapReadbackResult(true, true, false);
   }
 
   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_;
 };
 
 // Tests for the scheduler infinite-looping on SetNeedsCommit requests that
 // happen inside a ScheduledActionDrawAndSwap
 TEST(SchedulerTest, RequestCommitInsideDraw) {
-  SchedulerClientThatsetNeedsCommitInsideDraw client;
+  SchedulerClientThatSetNeedsCommitInsideDraw client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
-  scheduler->DidCreateAndInitializeOutputSurface();
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
+  client.Reset();
 
+  EXPECT_FALSE(client.needs_begin_frame());
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_EQ(0, client.num_draws());
   EXPECT_TRUE(client.needs_begin_frame());
 
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  client.SetNeedsCommitOnNextDraw();
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(client.needs_begin_frame());
   scheduler->FinishCommit();
 
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(2, client.num_draws());;
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->CommitPending());
+  EXPECT_TRUE(client.needs_begin_frame());
+
+  scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_FALSE(client.needs_begin_frame());
 }
 
 // Tests that when a draw fails then the pending commit should not be dropped.
 TEST(SchedulerTest, RequestCommitInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
-  scheduler->DidCreateAndInitializeOutputSurface();
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
+  client.Reset();
 
   client.SetDrawWillHappen(false);
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
 
   // Fail the draw.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(1, client.num_draws());
 
   // We have a commit pending and the draw failed, and we didn't lose the commit
   // request.
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Fail the draw again.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Draw successfully.
   client.SetDrawWillHappen(true);
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(3, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 }
 
 TEST(SchedulerTest, NoSwapWhenDrawFails) {
-  SchedulerClientThatsetNeedsCommitInsideDraw client;
+  SchedulerClientThatSetNeedsCommitInsideDraw client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
-  scheduler->DidCreateAndInitializeOutputSurface();
+  InitializeOutputSurfaceAndFirstCommit(scheduler);
+  client.Reset();
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
   EXPECT_EQ(0, client.num_draws());
 
   // Draw successfully, this starts a new frame.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(1, client.num_draws());
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Fail to draw, this should not start a frame.
   client.SetDrawWillHappen(false);
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginFrameDeadline();
   EXPECT_EQ(2, client.num_draws());
 }
 
 TEST(SchedulerTest, NoSwapWhenSwapFailsDuringForcedCommit) {
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
 
   // Tell the client that it will fail to swap.
   client.SetDrawWillHappen(true);
   client.SetSwapWillHappenIfDrawHappens(false);
 
-  // Get the compositor to do a ScheduledActionDrawAndSwapForced.
+  // Get the compositor to do a ScheduledActionDrawAndReadback.
   scheduler->SetCanDraw(true);
   scheduler->SetNeedsRedraw();
-  scheduler->SetNeedsForcedRedraw();
-  EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapForced"));
+  scheduler->SetNeedsForcedCommitForReadback();
+  scheduler->FinishCommit();
+  EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndReadback"));
+}
+
+TEST(SchedulerTest, BackToBackReadbackAllowed) {
+  // Some clients call readbacks twice in a row before the replacement
+  // commit comes in.  Make sure it is allowed.
+  FakeSchedulerClient client;
+  SchedulerSettings default_scheduler_settings;
+  Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
+
+  // Get the compositor to do 2 ScheduledActionDrawAndReadbacks before
+  // the replacement commit comes in.
+  scheduler->SetCanDraw(true);
+  scheduler->SetNeedsRedraw();
+  scheduler->SetNeedsForcedCommitForReadback();
+  scheduler->FinishCommit();
+  EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndReadback"));
+
+  client.Reset();
+  scheduler->SetNeedsForcedCommitForReadback();
+  scheduler->FinishCommit();
+  EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndReadback"));
+
+  // The replacement commit comes in after 2 readbacks.
+  client.Reset();
+  scheduler->FinishCommit();
 }
 
 }  // namespace
 }  // namespace cc