cc: Add readback and forced draw states to the Scheduler

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"
@@ skipping 72 matching lines @@
   // Scheduler Implementation.
   virtual void SetNeedsBeginFrameOnImplThread(bool enable) OVERRIDE {
     actions_.push_back("SetNeedsBeginFrameOnImplThread");
     states_.push_back(scheduler_->StateAsValue().release());
     needs_begin_frame_ = enable;
   }
   virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {
     actions_.push_back("ScheduledActionSendBeginFrameToMainThread");
     states_.push_back(scheduler_->StateAsValue().release());
   }
-  virtual ScheduledActionDrawAndSwapResult
-  ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
+      OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapIfPossible");
     states_.push_back(scheduler_->StateAsValue().release());
     num_draws_++;
-    return ScheduledActionDrawAndSwapResult(draw_will_happen_,
-                                            draw_will_happen_ &&
-                                            swap_will_happen_if_draw_happens_);
+    bool did_readback = false;
+    return DrawSwapReadbackResult(
+        draw_will_happen_,
+        draw_will_happen_ && swap_will_happen_if_draw_happens_,
+        did_readback);
   }
-  virtual ScheduledActionDrawAndSwapResult ScheduledActionDrawAndSwapForced()
-      OVERRIDE {
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapForced");
     states_.push_back(scheduler_->StateAsValue().release());
-    return ScheduledActionDrawAndSwapResult(true,
-                                            swap_will_happen_if_draw_happens_);
+    bool did_draw = true;
+    bool did_swap = swap_will_happen_if_draw_happens_;
+    bool did_readback = false;
+    return DrawSwapReadbackResult(did_draw, did_swap, did_readback);
+  }
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() OVERRIDE {
+    actions_.push_back("ScheduledActionDrawAndReadback");
+    states_.push_back(scheduler_->StateAsValue().release());
+    bool did_draw = true;
+    bool did_swap = false;
+    bool did_readback = true;
+    return DrawSwapReadbackResult(did_draw, did_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 274 matching lines @@
   // compositor is waiting for first draw should result in a request
   // for a new frame in order to escape a deadlock.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
   EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
 }
 
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
   virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {}
-  virtual ScheduledActionDrawAndSwapResult
-  ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
+      OVERRIDE {
     // Only SetNeedsRedraw the first time this is called
     if (!num_draws_)
       scheduler_->SetNeedsRedraw();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
-  virtual ScheduledActionDrawAndSwapResult ScheduledActionDrawAndSwapForced()
-      OVERRIDE {
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     NOTREACHED();
-    return ScheduledActionDrawAndSwapResult(true, true);
+    bool did_draw = true;
+    bool did_swap = true;
+    bool did_readback = false;
+    return DrawSwapReadbackResult(did_draw, did_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 67 matching lines @@
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 }
 
 class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
  public:
   SchedulerClientThatSetNeedsCommitInsideDraw()
       : set_needs_commit_on_next_draw_(false) {}
 
   virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {}
-  virtual ScheduledActionDrawAndSwapResult
-  ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
+      OVERRIDE {
     // 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 ScheduledActionDrawAndSwapResult ScheduledActionDrawAndSwapForced()
-      OVERRIDE {
+  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     NOTREACHED();
-    return ScheduledActionDrawAndSwapResult(true, true);
+    bool did_draw = true;
+    bool did_swap = false;
+    bool did_readback = false;
+    return DrawSwapReadbackResult(did_draw, did_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 107 matching lines @@
 
 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