cc: Make async readback path use async glRreadPixels.

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 2560 matching lines @@
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommitAndDrawFrame() {
+    WaitForCallback();
+  }
+
+  void WaitForCallback() {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &LayerTreeHostTestAsyncReadback::NextStep,
+            base::Unretained(this)));
+  }
+
+  void NextStep() {
     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());
+        if (callbacks_.size() < 1u) {
+          WaitForCallback();
+          return;
+        }
+        EXPECT_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());
+      case 3:
+        if (callbacks_.size() < 4u) {
+          WaitForCallback();
+          return;
+        }
+        EXPECT_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 void AfterTest() {
+    EXPECT_EQ(4u, callbacks_.size());
+  }
 
   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_;
@@ skipping 106 matching lines @@
   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