cc: Remove ReadPixels from compositor layer_unittests.cc

ui/compositor/layer_unittest.cc

 // Copyright (c) 2012 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/layers/layer.h"
+#include "cc/output/copy_output_request.h"
+#include "cc/output/copy_output_result.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/test/pixel_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/test/context_factories_for_test.h"
 #include "ui/compositor/test/draw_waiter_for_test.h"
 #include "ui/compositor/test/test_compositor_host.h"
@@ skipping 92 matching lines @@
     return layer;
   }
 
   void DrawTree(Layer* root) {
     GetCompositor()->SetRootLayer(root);
     GetCompositor()->ScheduleDraw();
     WaitForDraw();
   }
 
   bool ReadPixels(SkBitmap* bitmap) {
-    return GetCompositor()->ReadPixels(bitmap,
-                                       gfx::Rect(GetCompositor()->size()));
+    return ReadPixels(bitmap, gfx::Rect(GetCompositor()->size()));
+  }
+
+  bool ReadPixels(SkBitmap* bitmap, gfx::Rect source_rect) {
+    scoped_refptr<ReadbackHolder> holder(new ReadbackHolder);
+    scoped_ptr<cc::CopyOutputRequest> request =
+        cc::CopyOutputRequest::CreateBitmapRequest(
+            base::Bind(&ReadbackHolder::OutputRequestCallback, holder));
+    request->set_area(source_rect);
+
+    GetCompositor()->root_layer()->RequestCopyOfOutput(request.Pass());
+
+    // Wait for copy response.  This needs to wait as the compositor could
+    // be in the middle of a draw right now, and the commit with the
+    // copy output request may not be done on the first draw.
+    for (int i = 0; i < 2; i++) {
+      GetCompositor()->ScheduleDraw();
+      WaitForDraw();
+    }
+
+    if (holder->completed()) {
+      *bitmap = holder->result();
+      return true;
+    }
+
+    // Callback never called.
+    NOTREACHED();
+    return false;
   }
 
   void WaitForDraw() {
     ui::DrawWaiterForTest::Wait(GetCompositor());
   }
 
   void WaitForCommit() {
     ui::DrawWaiterForTest::WaitForCommit(GetCompositor());
   }
 
   // Invalidates the entire contents of the layer.
   void SchedulePaintForLayer(Layer* layer) {
     layer->SchedulePaint(
         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
   }
 
   const base::FilePath& test_data_directory() const {
     return test_data_directory_;
   }
 
  private:
+  class ReadbackHolder : public base::RefCountedThreadSafe<ReadbackHolder> {
+   public:
+    ReadbackHolder() : completed_(false) {}
+
+    void OutputRequestCallback(scoped_ptr<cc::CopyOutputResult> result) {
+      DCHECK(!completed_);
+      result_ = result->TakeBitmap();
+      completed_ = true;
+    }
+    bool completed() const {
+      return completed_;
+    };
+    const SkBitmap& result() const { return *result_; }
+
+   private:
+    friend class base::RefCountedThreadSafe<ReadbackHolder>;
+
+    virtual ~ReadbackHolder() {}
+
+    scoped_ptr<SkBitmap> result_;
+    bool completed_;
+  };
+
   scoped_ptr<TestCompositorHost> window_;
 
   // The root directory for test files.
   base::FilePath test_data_directory_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerWithRealCompositorTest);
 };
 
 // LayerDelegate that paints colors to the layer.
 class TestLayerDelegate : public LayerDelegate {
@@ skipping 634 matching lines @@
       CreateColorLayer(SK_ColorRED, gfx::Rect(viewport_size)));
   scoped_ptr<Layer> layer2(
       CreateColorLayer(SK_ColorBLUE,
                        gfx::Rect(0, 0, viewport_size.width(), blue_height)));
 
   layer->Add(layer2.get());
 
   DrawTree(layer.get());
 
   SkBitmap bitmap;
-  ASSERT_TRUE(GetCompositor()->ReadPixels(&bitmap, gfx::Rect(viewport_size)));
+  ASSERT_TRUE(ReadPixels(&bitmap, gfx::Rect(viewport_size)));
   ASSERT_FALSE(bitmap.empty());
 
   SkAutoLockPixels lock(bitmap);
   for (int x = 0; x < viewport_size.width(); x++) {
     for (int y = 0; y < viewport_size.height(); y++) {
       SkColor actual_color = bitmap.getColor(x, y);
       SkColor expected_color = y < blue_height ? SK_ColorBLUE : SK_ColorRED;
       EXPECT_EQ(expected_color, actual_color)
           << "Pixel error at x=" << x << " y=" << y << "; "
           << "actual RGBA=("
@@ skipping 645 matching lines @@
   l1->SetOpacity(0.5f);
 
   // Change l1's cc::Layer.
   l1->SwitchCCLayerForTest();
 
   // Ensure that the opacity animation completed.
   EXPECT_FLOAT_EQ(l1->opacity(), 0.5f);
 }
 
 }  // namespace ui