Revert 196713 "cc: Async readback."

Oops, wrong version landed!

> 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

TBR=danakj@chromium.org

Review URL: https://codereview.chromium.org/14512003

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

7 files changed, 35 insertions, 62 deletions

diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 7d0083f..ae8ff9b 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -8,7 +8,6 @@
 #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"
@@ -193,19 +192,9 @@ 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 4153750..bb3095a 100644
--- a/cc/output/direct_renderer.h
+++ b/cc/output/direct_renderer.h
@@ -109,8 +109,6 @@ 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 4a0c7ba..19b215b 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -1776,19 +1776,6 @@ 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 b05d02b..091d94e 100644
--- a/cc/output/gl_renderer.h
+++ b/cc/output/gl_renderer.h
@@ -103,8 +103,6 @@ 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 965b5cc..8da1b24 100644
--- a/cc/output/gl_renderer_pixeltest.cc
+++ b/cc/output/gl_renderer_pixeltest.cc
@@ -92,13 +92,14 @@ TEST_F(GLRendererPixelTest, SimpleGreenRect) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
-  EXPECT_TRUE(RunPixelTest(
-      &pass_list,
+  renderer_->DrawFrame(&pass_list);
+
+  EXPECT_TRUE(PixelsMatchReference(
       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);
@@ -167,8 +168,7 @@ 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,13 +186,16 @@ TEST_F(GLRendererPixelTest, FastPassColorFilterAlpha) {
   pass_list.push_back(child_pass.Pass());
   pass_list.push_back(root_pass.Pass());
 
-  EXPECT_TRUE(RunPixelTest(
-      &pass_list,
+  renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75));
+  renderer_->DecideRenderPassAllocationsForFrame(pass_list);
+  renderer_->DrawFrame(&pass_list);
+
+  EXPECT_TRUE(PixelsMatchReference(
       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);
@@ -283,8 +286,11 @@ TEST_F(GLRendererPixelTest, FastPassColorFilterAlphaTranslation) {
   pass_list.push_back(child_pass.Pass());
   pass_list.push_back(root_pass.Pass());
 
-  EXPECT_TRUE(RunPixelTest(
-      &pass_list,
+  renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75));
+  renderer_->DecideRenderPassAllocationsForFrame(pass_list);
+  renderer_->DrawFrame(&pass_list);
+
+  EXPECT_TRUE(PixelsMatchReference(
       base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")),
       ExactPixelComparator(false)));
 }
@@ -336,16 +342,17 @@ 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(RunPixelTest(
-      &pass_list,
+  EXPECT_TRUE(PixelsMatchReference(
       base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")),
       ExactPixelComparator(true)));
 }
 
 class GLRendererPixelTestWithBackgroundFilter : public GLRendererPixelTest {
  protected:
-  void SetUpRenderPassList() {
+  void DrawFrame() {
     gfx::Rect device_viewport_rect(device_viewport_size_);
 
     RenderPass::Id root_id(1, 1);
@@ -445,11 +452,14 @@ 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());
 
-    pass_list_.push_back(filter_pass.Pass());
-    pass_list_.push_back(root_pass.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);
   }
 
-  RenderPassList pass_list_;
   WebKit::WebFilterOperations background_filters_;
   gfx::Transform filter_pass_to_target_transform_;
   gfx::Rect filter_pass_content_rect_;
@@ -462,9 +472,8 @@ TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) {
   filter_pass_content_rect_ = gfx::Rect(device_viewport_size_);
   filter_pass_content_rect_.Inset(12, 14, 16, 18);
 
-  SetUpRenderPassList();
-  EXPECT_TRUE(RunPixelTest(
-      &pass_list_,
+  DrawFrame();
+  EXPECT_TRUE(PixelsMatchReference(
       base::FilePath(FILE_PATH_LITERAL("background_filter.png")),
       ExactPixelComparator(true)));
 }
@@ -473,7 +482,9 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {
   gfx::Rect rect(0, 0, 200, 200);
 
   RenderPass::Id id(1, 1);
-  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
+  gfx::Transform transform_to_root;
+  scoped_ptr<RenderPass> pass =
+      CreateTestRenderPass(id, rect, transform_to_root);
 
   gfx::Transform red_content_to_target_transform;
   red_content_to_target_transform.Rotate(10);
@@ -507,8 +518,9 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
-  EXPECT_TRUE(RunPixelTest(
-      &pass_list,
+  renderer_->DrawFrame(&pass_list);
+
+  EXPECT_TRUE(PixelsMatchReference(
       base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")),
       ExactPixelComparator(true)));
 }
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 69c3b7e..fec4f3e 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -407,15 +407,6 @@ 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 90e6ed2..159044f 100644
--- a/cc/output/software_renderer.h
+++ b/cc/output/software_renderer.h
@@ -58,8 +58,6 @@ 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(