cc: Add readback and forced draw states to the Scheduler

cc/trees/layer_tree_host_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/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 485 matching lines @@
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_commits_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestCompositeAndReadbackBeforePreviousCommitDraws);
 
+class LayerTreeHostTestCompositeAndReadbackDuringForcedDraw
+    : public LayerTreeHostTest {
+ protected:
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    // This enables forced draws after a single prepare to draw failure.
+    settings->timeout_and_draw_when_animation_checkerboards = true;
+    settings->maximum_number_of_failed_draws_before_draw_is_forced_ = 1;
+  }
+
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+
+  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                     LayerTreeHostImpl::FrameData* frame_data,
+                                     bool result) OVERRIDE {
+    EXPECT_GE(host_impl->active_tree()->source_frame_number(), 0);
+    EXPECT_LE(host_impl->active_tree()->source_frame_number(), 2);
+
+    // Before we react to the failed draw by initiating the forced draw
+    // sequence, start a readback on the main thread.
+    if (host_impl->active_tree()->source_frame_number() == 0)
+      PostReadbackToMainThread();
+
+    // Returning false will eventually result in a forced draw.
+    return false;
+  }
+
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    // We should only draw for the readback and the forced draw.
+    EXPECT_GE(host_impl->active_tree()->source_frame_number(), 1);
+    EXPECT_LE(host_impl->active_tree()->source_frame_number(), 2);
+  }
+
+  virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
+                                   bool result) OVERRIDE {
+    // We should only swap for the forced draw.
+    EXPECT_EQ(host_impl->active_tree()->source_frame_number(), 2);
+    EndTest();
+  }
+
+  virtual void AfterTest() OVERRIDE {}
+};
+
+MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadbackDuringForcedDraw);
+
+class LayerTreeHostTestCompositeAndReadbackAfterForcedDraw
+    : public LayerTreeHostTest {
+ protected:
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    // This enables forced draws after a single prepare to draw failure.
+    settings->timeout_and_draw_when_animation_checkerboards = true;
+    settings->maximum_number_of_failed_draws_before_draw_is_forced_ = 1;
+  }
+
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+
+  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                     LayerTreeHostImpl::FrameData* frame_data,
+                                     bool result) OVERRIDE {
+    EXPECT_GE(host_impl->active_tree()->source_frame_number(), 0);
+    EXPECT_LE(host_impl->active_tree()->source_frame_number(), 3);
+
+    // Returning false will eventually result in a forced draw.
+    return false;
+  }
+
+  virtual void DidCommit() OVERRIDE {
+    if (layer_tree_host()->source_frame_number() == 1) {
+      // Avoid aborting the forced draw commit so source_frame_number
+      // increments.
+      layer_tree_host()->SetNeedsCommit();
+    } else if (layer_tree_host()->source_frame_number() == 2) {
+      // Perform a readback immediately after the forced draw's commit.
+      char pixels[4];
+      layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
+    }
+  }
+
+  virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    // We should only draw for the the forced draw, readback, and
+    // replacement commit.
+    EXPECT_GE(host_impl->active_tree()->source_frame_number(), 1);
+    EXPECT_LE(host_impl->active_tree()->source_frame_number(), 3);
+  }
+
+  virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
+                                   bool result) OVERRIDE {
+    // We should only swap for the forced draw and replacement commit.
+    EXPECT_TRUE(host_impl->active_tree()->source_frame_number() == 1 ||
+                host_impl->active_tree()->source_frame_number() == 3);
+    if (host_impl->active_tree()->source_frame_number() == 3)
+      EndTest();
+  }
+
+  virtual void AfterTest() OVERRIDE {}
+};
+
+MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadbackAfterForcedDraw);
+
 // If the layerTreeHost says it can't draw, Then we should not try to draw.
 class LayerTreeHostTestCanDrawBlocksDrawing : public LayerTreeHostTest {
  public:
   LayerTreeHostTestCanDrawBlocksDrawing() : num_commits_(0), done_(false) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (done_)
       return;
@@ skipping 3944 matching lines @@
   int num_will_begin_frames_;
   int num_impl_commits_;
 };
 
 // Commits can only be aborted when using the thread proxy.
 MULTI_THREAD_TEST_F(LayerTreeHostTestAbortEvictedTextures);
 
 }  // namespace
 
 }  // namespace cc