cc: Async readback.

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/synchronization/lock.h"
 #include "cc/animation/timing_function.h"
@@ skipping 2541 matching lines @@
 
   virtual void AfterTest() OVERRIDE {}
 
   int io_surface_id_;
   MockIOSurfaceWebGraphicsContext3D* mock_context_;
   gfx::Size io_surface_size_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestIOSurfaceDrawing);
 
+class LayerTreeHostTestAsyncReadback : public LayerTreeHostTest {
+ protected:
+  virtual void SetupTree() OVERRIDE {
+    root = FakeContentLayer::Create(&client_);
+    root->SetBounds(gfx::Size(20, 20));
+
+    child = FakeContentLayer::Create(&client_);
+    child->SetBounds(gfx::Size(10, 10));
+    root->AddChild(child);
+
+    layer_tree_host()->SetRootLayer(root);
+    LayerTreeHostTest::SetupTree();
+  }
+
+  virtual void BeginTest() OVERRIDE {
+    PostSetNeedsCommitToMainThread();
+  }
+
+  virtual void DidCommitAndDrawFrame() {
+    int frame = layer_tree_host()->commit_number();
+    switch (frame) {
+      case 1:
+        child->RequestCopyAsBitmap(base::Bind(
+            &LayerTreeHostTestAsyncReadback::BitmapCallback,
+            base::Unretained(this)));
+        EXPECT_EQ(0u, callbacks_.size());
+        break;
+      case 2:
+        // Flush the message loops and make sure the callbacks run.
+        layer_tree_host()->SetNeedsCommit();
+        break;
+      case 3:
+        ASSERT_EQ(1u, callbacks_.size());
+        EXPECT_EQ(gfx::Size(10, 10).ToString(), callbacks_[0].ToString());
+
+        child->RequestCopyAsBitmap(base::Bind(
+            &LayerTreeHostTestAsyncReadback::BitmapCallback,
+            base::Unretained(this)));
+        root->RequestCopyAsBitmap(base::Bind(
+            &LayerTreeHostTestAsyncReadback::BitmapCallback,
+            base::Unretained(this)));
+        child->RequestCopyAsBitmap(base::Bind(
+            &LayerTreeHostTestAsyncReadback::BitmapCallback,
+            base::Unretained(this)));
+        EXPECT_EQ(1u, callbacks_.size());
+        break;
+      case 4:
+        // Flush the message loops and make sure the callbacks run.
+        layer_tree_host()->SetNeedsCommit();
+        break;
+      case 5:
+        ASSERT_EQ(4u, callbacks_.size());
+        // The child was copied to a bitmap and passed back twice.
+        EXPECT_EQ(gfx::Size(10, 10).ToString(), callbacks_[1].ToString());
+        EXPECT_EQ(gfx::Size(10, 10).ToString(), callbacks_[2].ToString());
+        // The root was copied to a bitmap and passed back also.
+        EXPECT_EQ(gfx::Size(20, 20).ToString(), callbacks_[3].ToString());
+        EndTest();
+        break;
+    }
+  }
+
+  void BitmapCallback(scoped_ptr<SkBitmap> bitmap) {
+    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    EXPECT_TRUE(bitmap);
+    callbacks_.push_back(gfx::Size(bitmap->width(), bitmap->height()));
+  }
+
+  virtual void AfterTest() {}
+
+  virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
+    if (use_gl_renderer_)
+      return FakeOutputSurface::Create3d().PassAs<OutputSurface>();
+    return FakeOutputSurface::CreateSoftware(
+        make_scoped_ptr(new SoftwareOutputDevice)).PassAs<OutputSurface>();
+  }
+
+  bool use_gl_renderer_;
+  std::vector<gfx::Size> callbacks_;
+  FakeContentLayerClient client_;
+  scoped_refptr<FakeContentLayer> root;
+  scoped_refptr<FakeContentLayer> child;
+};
+
+TEST_F(LayerTreeHostTestAsyncReadback, GLRenderer_RunSingleThread) {
+  use_gl_renderer_ = true;
+  RunTest(false);
+}
+
+TEST_F(LayerTreeHostTestAsyncReadback, GLRenderer_RunMultiThread) {
+  use_gl_renderer_ = true;
+  RunTest(true);
+}
+
+TEST_F(LayerTreeHostTestAsyncReadback, SoftwareRenderer_RunSingleThread) {
+  use_gl_renderer_ = false;
+  RunTest(false);
+}
+
+TEST_F(LayerTreeHostTestAsyncReadback, SoftwareRenderer_RunMultiThread) {
+  use_gl_renderer_ = false;
+  RunTest(true);
+}
+
+class LayerTreeHostTestAsyncReadbackLayerDestroyed : public LayerTreeHostTest {
+ protected:
+  virtual void SetupTree() OVERRIDE {
+    root_ = FakeContentLayer::Create(&client_);
+    root_->SetBounds(gfx::Size(20, 20));
+
+    main_destroyed_ = FakeContentLayer::Create(&client_);
+    main_destroyed_->SetBounds(gfx::Size(15, 15));
+    root_->AddChild(main_destroyed_);
+
+    impl_destroyed_ = FakeContentLayer::Create(&client_);
+    impl_destroyed_->SetBounds(gfx::Size(10, 10));
+    root_->AddChild(impl_destroyed_);
+
+    layer_tree_host()->SetRootLayer(root_);
+    LayerTreeHostTest::SetupTree();
+  }
+
+  virtual void BeginTest() OVERRIDE {
+    callback_count_ = 0;
+    PostSetNeedsCommitToMainThread();
+  }
+
+  virtual void DidCommit() {
+    int frame = layer_tree_host()->commit_number();
+    switch (frame) {
+      case 1:
+        main_destroyed_->RequestCopyAsBitmap(base::Bind(
+            &LayerTreeHostTestAsyncReadbackLayerDestroyed::BitmapCallback,
+            base::Unretained(this)));
+        impl_destroyed_->RequestCopyAsBitmap(base::Bind(
+            &LayerTreeHostTestAsyncReadbackLayerDestroyed::BitmapCallback,
+            base::Unretained(this)));
+        EXPECT_EQ(0, callback_count_);
+
+        // Destroy the main thread layer right away.
+        main_destroyed_->RemoveFromParent();
+        main_destroyed_ = NULL;
+
+        // Should callback with a NULL bitmap.
+        EXPECT_EQ(1, callback_count_);
+
+        // Prevent drawing so we can't make a copy of the impl_destroyed layer.
+        layer_tree_host()->SetViewportSize(gfx::Size());
+        break;
+      case 2:
+        // Flush the message loops and make sure the callbacks run.
+        layer_tree_host()->SetNeedsCommit();
+        break;
+      case 3:
+        // No drawing means no readback yet.
+        EXPECT_EQ(1, callback_count_);
+
+        // Destroy the impl thread layer.
+        impl_destroyed_->RemoveFromParent();
+        impl_destroyed_ = NULL;
+
+        // No callback yet because it's on the impl side.
+        EXPECT_EQ(1, callback_count_);
+        break;
+      case 4:
+        // Flush the message loops and make sure the callbacks run.
+        layer_tree_host()->SetNeedsCommit();
+        break;
+      case 5:
+        // We should get another callback with a NULL bitmap.
+        EXPECT_EQ(2, callback_count_);
+        EndTest();
+        break;
+    }
+  }
+
+  void BitmapCallback(scoped_ptr<SkBitmap> bitmap) {
+    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    EXPECT_FALSE(bitmap);
+    ++callback_count_;
+  }
+
+  virtual void AfterTest() {}
+
+  int callback_count_;
+  FakeContentLayerClient client_;
+  scoped_refptr<FakeContentLayer> root_;
+  scoped_refptr<FakeContentLayer> main_destroyed_;
+  scoped_refptr<FakeContentLayer> impl_destroyed_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAsyncReadbackLayerDestroyed);
+
 }  // namespace
 }  // namespace cc