cc: Async readback.

Provide a path to get a readback of a layer's subtree via an
asynchronous mechanism.

This path is used for all the cc pixel tests, to show that it
works. Also by some unit tests:

LayerTreeHostTestAsyncReadback.GLRenderer_RunSingleThread
LayerTreeHostTestAsyncReadback.GLRenderer_RunMultiThread
LayerTreeHostTestAsyncReadback.SoftwareRenderer_RunSingleThread
LayerTreeHostTestAsyncReadback.SoftwareRenderer_RunMultiThread
LayerTreeHostTestAsyncReadbackLayerDestroyed.RunSingleThread
LayerTreeHostTestAsyncReadbackLayerDestroyed.RunMultiThread

BUG=179896

Review URL: https://chromiumcodereview.appspot.com/14060015

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@196747 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 64 insertions, 38 deletions

diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index ae8ff9b..7d0083f 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "base/debug/trace_event.h"
+#include "base/hash_tables.h"
 #include "base/metrics/histogram.h"
 #include "cc/base/math_util.h"
 #include "cc/quads/draw_quad.h"
@@ -192,9 +193,19 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order) {
       root_render_pass->damage_rect : root_render_pass->output_rect;
   frame.root_damage_rect.Intersect(gfx::Rect(ViewportSize()));
 
+  std::vector<base::Closure> copy_callbacks;
+
   BeginDrawingFrame(&frame);
-  for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i)
+  for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
     DrawRenderPass(&frame, render_passes_in_draw_order->at(i));
+
+    const RenderPass* pass = frame.current_render_pass;
+    for (size_t i = 0; i < pass->copy_callbacks.size(); ++i) {
+      scoped_ptr<SkBitmap> bitmap(new SkBitmap);
+      CopyCurrentRenderPassToBitmap(&frame, bitmap.get());
+      pass->copy_callbacks[i].Run(bitmap.Pass());
+    }
+  }
   FinishDrawingFrame(&frame);
 
   render_passes_in_draw_order->clear();
diff --git a/cc/output/direct_renderer.h b/cc/output/direct_renderer.h
index bb3095a..4153750 100644
--- a/cc/output/direct_renderer.h
+++ b/cc/output/direct_renderer.h
@@ -109,6 +109,8 @@ class CC_EXPORT DirectRenderer : public Renderer {
   virtual bool FlippedFramebuffer() const = 0;
   virtual void EnsureScissorTestEnabled() = 0;
   virtual void EnsureScissorTestDisabled() = 0;
+  virtual void CopyCurrentRenderPassToBitmap(DrawingFrame* frame,
+                                             SkBitmap* bitmap) = 0;
 
   ScopedPtrHashMap<RenderPass::Id, CachedResource> render_pass_textures_;
   ResourceProvider* resource_provider_;
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 19b215b..4a0c7ba 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -1776,6 +1776,19 @@ void GLRenderer::EnsureScissorTestDisabled() {
   is_scissor_enabled_ = false;
 }
 
+void GLRenderer::CopyCurrentRenderPassToBitmap(DrawingFrame* frame,
+                                               SkBitmap* bitmap) {
+  gfx::Size render_pass_size = frame->current_render_pass->output_rect.size();
+  bitmap->setConfig(SkBitmap::kARGB_8888_Config,
+                    render_pass_size.width(),
+                    render_pass_size.height());
+  if (bitmap->allocPixels()) {
+    bitmap->lockPixels();
+    GetFramebufferPixels(bitmap->getPixels(), gfx::Rect(render_pass_size));
+    bitmap->unlockPixels();
+  }
+}
+
 void GLRenderer::ToGLMatrix(float* gl_matrix, const gfx::Transform& transform) {
   transform.matrix().asColMajorf(gl_matrix);
 }
diff --git a/cc/output/gl_renderer.h b/cc/output/gl_renderer.h
index 091d94e..b05d02b 100644
--- a/cc/output/gl_renderer.h
+++ b/cc/output/gl_renderer.h
@@ -103,6 +103,8 @@ class CC_EXPORT GLRenderer
   virtual bool FlippedFramebuffer() const OVERRIDE;
   virtual void EnsureScissorTestEnabled() OVERRIDE;
   virtual void EnsureScissorTestDisabled() OVERRIDE;
+  virtual void CopyCurrentRenderPassToBitmap(DrawingFrame* frame,
+                                             SkBitmap* bitmap) OVERRIDE;
   virtual void FinishDrawingQuadList() OVERRIDE;
 
  private:
diff --git a/cc/output/gl_renderer_pixeltest.cc b/cc/output/gl_renderer_pixeltest.cc
index 8da1b24..02f783e 100644
--- a/cc/output/gl_renderer_pixeltest.cc
+++ b/cc/output/gl_renderer_pixeltest.cc
@@ -92,14 +92,13 @@ TEST_F(GLRendererPixelTest, SimpleGreenRect) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
-  renderer_->DrawFrame(&pass_list);
-
-  EXPECT_TRUE(PixelsMatchReference(
+  EXPECT_TRUE(RunPixelTest(
+      &pass_list,
       base::FilePath(FILE_PATH_LITERAL("green.png")),
       ExactPixelComparator(true)));
 }
 
-TEST_F(GLRendererPixelTest, fastPassColorFilterAlpha) {
+TEST_F(GLRendererPixelTest, FastPassColorFilterAlpha) {
   gfx::Rect viewport_rect(device_viewport_size_);
 
   RenderPass::Id root_pass_id(1, 1);
@@ -168,7 +167,8 @@ TEST_F(GLRendererPixelTest, fastPassColorFilterAlpha) {
   skia::RefPtr<SkImageFilter> filter =
       skia::AdoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), NULL));
 
-  scoped_ptr<RenderPassDrawQuad> render_pass_quad = RenderPassDrawQuad::Create();
+  scoped_ptr<RenderPassDrawQuad> render_pass_quad =
+      RenderPassDrawQuad::Create();
   render_pass_quad->SetNew(pass_shared_state.get(),
                            pass_rect,
                            child_pass_id,
@@ -186,16 +186,13 @@ TEST_F(GLRendererPixelTest, fastPassColorFilterAlpha) {
   pass_list.push_back(child_pass.Pass());
   pass_list.push_back(root_pass.Pass());
 
-  renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75));
-  renderer_->DecideRenderPassAllocationsForFrame(pass_list);
-  renderer_->DrawFrame(&pass_list);
-
-  EXPECT_TRUE(PixelsMatchReference(
+  EXPECT_TRUE(RunPixelTest(
+      &pass_list,
       base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")),
       ExactPixelComparator(false)));
 }
 
-TEST_F(GLRendererPixelTest, fastPassColorFilterAlphaTranslation) {
+TEST_F(GLRendererPixelTest, FastPassColorFilterAlphaTranslation) {
   gfx::Rect viewport_rect(device_viewport_size_);
 
   RenderPass::Id root_pass_id(1, 1);
@@ -286,11 +283,8 @@ TEST_F(GLRendererPixelTest, fastPassColorFilterAlphaTranslation) {
   pass_list.push_back(child_pass.Pass());
   pass_list.push_back(root_pass.Pass());
 
-  renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75));
-  renderer_->DecideRenderPassAllocationsForFrame(pass_list);
-  renderer_->DrawFrame(&pass_list);
-
-  EXPECT_TRUE(PixelsMatchReference(
+  EXPECT_TRUE(RunPixelTest(
+      &pass_list,
       base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")),
       ExactPixelComparator(false)));
 }
@@ -342,17 +336,16 @@ TEST_F(GLRendererPixelTest, RenderPassChangesSize) {
   pass_list.push_back(root_pass.Pass());
 
   renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75));
-  renderer_->DecideRenderPassAllocationsForFrame(pass_list);
-  renderer_->DrawFrame(&pass_list);
 
-  EXPECT_TRUE(PixelsMatchReference(
+  EXPECT_TRUE(RunPixelTest(
+      &pass_list,
       base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")),
       ExactPixelComparator(true)));
 }
 
 class GLRendererPixelTestWithBackgroundFilter : public GLRendererPixelTest {
  protected:
-  void DrawFrame() {
+  void SetUpRenderPassList() {
     gfx::Rect device_viewport_rect(device_viewport_size_);
 
     RenderPass::Id root_id(1, 1);
@@ -452,14 +445,11 @@ class GLRendererPixelTestWithBackgroundFilter : public GLRendererPixelTest {
     root_pass->quad_list.push_back(background_quad.PassAs<DrawQuad>());
     root_pass->shared_quad_state_list.push_back(shared_state.Pass());
 
-    RenderPassList pass_list;
-    pass_list.push_back(filter_pass.Pass());
-    pass_list.push_back(root_pass.Pass());
-
-    renderer_->DecideRenderPassAllocationsForFrame(pass_list);
-    renderer_->DrawFrame(&pass_list);
+    pass_list_.push_back(filter_pass.Pass());
+    pass_list_.push_back(root_pass.Pass());
   }
 
+  RenderPassList pass_list_;
   WebKit::WebFilterOperations background_filters_;
   gfx::Transform filter_pass_to_target_transform_;
   gfx::Rect filter_pass_content_rect_;
@@ -472,8 +462,9 @@ TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) {
   filter_pass_content_rect_ = gfx::Rect(device_viewport_size_);
   filter_pass_content_rect_.Inset(12, 14, 16, 18);
 
-  DrawFrame();
-  EXPECT_TRUE(PixelsMatchReference(
+  SetUpRenderPassList();
+  EXPECT_TRUE(RunPixelTest(
+      &pass_list_,
       base::FilePath(FILE_PATH_LITERAL("background_filter.png")),
       ExactPixelComparator(true)));
 }
@@ -482,9 +473,7 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {
   gfx::Rect rect(0, 0, 200, 200);
 
   RenderPass::Id id(1, 1);
-  gfx::Transform transform_to_root;
-  scoped_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, rect, transform_to_root);
+  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   gfx::Transform red_content_to_target_transform;
   red_content_to_target_transform.Rotate(10);
@@ -518,9 +507,8 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
-  renderer_->DrawFrame(&pass_list);
-
-  EXPECT_TRUE(PixelsMatchReference(
+  EXPECT_TRUE(RunPixelTest(
+      &pass_list,
       base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")),
       ExactPixelComparator(true)));
 }
@@ -569,9 +557,8 @@ TEST_F(GLRendererPixelTest, AxisAligned) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
-  renderer_->DrawFrame(&pass_list);
-
-  EXPECT_TRUE(PixelsMatchReference(
+  EXPECT_TRUE(RunPixelTest(
+      &pass_list,
       base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")),
       ExactPixelComparator(true)));
 }
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index fec4f3e..69c3b7e 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -407,6 +407,15 @@ void SoftwareRenderer::DrawUnsupportedQuad(const DrawingFrame* frame,
                             current_paint_);
 }
 
+void SoftwareRenderer::CopyCurrentRenderPassToBitmap(DrawingFrame* frame,
+                                                     SkBitmap* bitmap) {
+  gfx::Size render_pass_size = frame->current_render_pass->output_rect.size();
+  bitmap->setConfig(SkBitmap::kARGB_8888_Config,
+                    render_pass_size.width(),
+                    render_pass_size.height());
+  current_canvas_->readPixels(bitmap, 0, 0);
+}
+
 void SoftwareRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
   TRACE_EVENT0("cc", "SoftwareRenderer::GetFramebufferPixels");
   SkBitmap subset_bitmap;
diff --git a/cc/output/software_renderer.h b/cc/output/software_renderer.h
index 159044f..90e6ed2 100644
--- a/cc/output/software_renderer.h
+++ b/cc/output/software_renderer.h
@@ -58,6 +58,8 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
   virtual bool FlippedFramebuffer() const OVERRIDE;
   virtual void EnsureScissorTestEnabled() OVERRIDE;
   virtual void EnsureScissorTestDisabled() OVERRIDE;
+  virtual void CopyCurrentRenderPassToBitmap(DrawingFrame* frame,
+                                             SkBitmap* bitmap) OVERRIDE;
 
  private:
   SoftwareRenderer(