Revert 254567 "don't create SkDevice directly, use SkBitmap or (..."

trunk/src/media/filters/skcanvas_video_renderer_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 "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmapDevice.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "media/filters/skcanvas_video_renderer.h"
 
 using media::VideoFrame;
 
 namespace media {
 
 static const int kWidth = 320;
 static const int kHeight = 240;
 static const gfx::Rect kNaturalRect(0, 0, kWidth, kHeight);
 
 // Helper for filling a |canvas| with a solid |color|.
 void FillCanvas(SkCanvas* canvas, SkColor color) {
-  canvas->clear(color);
+  const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(true);
+  bitmap.lockPixels();
+  bitmap.eraseColor(color);
+  bitmap.unlockPixels();
 }
 
 // Helper for returning the color of a solid |canvas|.
 SkColor GetColorAt(SkCanvas* canvas, int x, int y) {
-  SkBitmap bitmap;
-  if (!bitmap.allocN32Pixels(1, 1))
-    return 0;
-  if (!canvas->readPixels(&bitmap, x, y))
-    return 0;
-  return bitmap.getColor(0, 0);
+  const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(false);
+  bitmap.lockPixels();
+  SkColor c = bitmap.getColor(x, y);
+  bitmap.unlockPixels();
+  return c;
 }
 
 SkColor GetColor(SkCanvas* canvas) {
   return GetColorAt(canvas, 0, 0);
 }
 
 class SkCanvasVideoRendererTest : public testing::Test {
  public:
   enum Color {
     kNone,
@@ skipping 23 matching lines @@
   SkCanvas* slow_path_canvas() { return &slow_path_canvas_; }
 
  private:
   SkCanvasVideoRenderer renderer_;
 
   scoped_refptr<VideoFrame> natural_frame_;
   scoped_refptr<VideoFrame> larger_frame_;
   scoped_refptr<VideoFrame> smaller_frame_;
   scoped_refptr<VideoFrame> cropped_frame_;
 
+  SkBitmapDevice fast_path_device_;
   SkCanvas fast_path_canvas_;
+  SkBitmapDevice slow_path_device_;
   SkCanvas slow_path_canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(SkCanvasVideoRendererTest);
 };
 
-static SkBitmap alloc_bitmap(int width, int height, bool isOpaque) {
-  SkAlphaType alphaType = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-  SkBitmap bitmap;
-
-  bitmap.allocPixels(SkImageInfo::MakeN32(width, height, alphaType));
-  return bitmap;
-}
-
 SkCanvasVideoRendererTest::SkCanvasVideoRendererTest()
     : natural_frame_(VideoFrame::CreateBlackFrame(gfx::Size(kWidth, kHeight))),
       larger_frame_(VideoFrame::CreateBlackFrame(
           gfx::Size(kWidth * 2, kHeight * 2))),
       smaller_frame_(VideoFrame::CreateBlackFrame(
           gfx::Size(kWidth / 2, kHeight / 2))),
       cropped_frame_(VideoFrame::CreateFrame(
           VideoFrame::YV12,
           gfx::Size(16, 16),
           gfx::Rect(6, 6, 8, 6),
           gfx::Size(8, 6),
           base::TimeDelta::FromMilliseconds(4))),
-      fast_path_canvas_(alloc_bitmap(kWidth, kHeight, true)),
-      slow_path_canvas_(alloc_bitmap(kWidth, kHeight, false)) {
+      fast_path_device_(SkBitmap::kARGB_8888_Config, kWidth, kHeight, true),
+      fast_path_canvas_(&fast_path_device_),
+      slow_path_device_(SkBitmap::kARGB_8888_Config, kWidth, kHeight, false),
+      slow_path_canvas_(&slow_path_device_) {
   // Give each frame a unique timestamp.
   natural_frame_->SetTimestamp(base::TimeDelta::FromMilliseconds(1));
   larger_frame_->SetTimestamp(base::TimeDelta::FromMilliseconds(2));
   smaller_frame_->SetTimestamp(base::TimeDelta::FromMilliseconds(3));
 
   // Make sure the cropped video frame's aspect ratio matches the output device.
   // Update cropped_frame_'s crop dimensions if this is not the case.
   EXPECT_EQ(cropped_frame()->natural_size().width() * kHeight,
       cropped_frame()->natural_size().height() * kWidth);
 
@@ skipping 227 matching lines @@
                                                           kHeight * 1 / 6 - 1));
   EXPECT_EQ(SK_ColorRED,   GetColorAt(slow_path_canvas(), kWidth  * 3 / 8,
                                                           kHeight * 1 / 6 - 1));
   EXPECT_EQ(SK_ColorGREEN, GetColorAt(slow_path_canvas(), kWidth  * 1 / 8 - 1,
                                                           kHeight * 3 / 6));
   EXPECT_EQ(SK_ColorBLUE,  GetColorAt(slow_path_canvas(), kWidth  * 3 / 8,
                                                           kHeight * 3 / 6));
 }
 
 }  // namespace media