Paint: remove readPixels.

media/renderers/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 <GLES3/gl3.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 15 matching lines @@
 #include "ui/gfx/geometry/rect_f.h"
 
 using media::VideoFrame;
 
 namespace media {
 
 static const int kWidth = 320;
 static const int kHeight = 240;
 static const gfx::RectF kNaturalRect(kWidth, kHeight);
 
-// Helper for filling a |canvas| with a solid |color|.
-void FillCanvas(cc::PaintCanvas* canvas, SkColor color) {
-  canvas->clear(color);
-}
-
-// Helper for returning the color of a solid |canvas|.
-SkColor GetColorAt(cc::PaintCanvas* canvas, int x, int y) {
-  SkBitmap bitmap;
-  if (!bitmap.tryAllocN32Pixels(1, 1))
-    return 0;
-  if (!canvas->readPixels(&bitmap, x, y))
-    return 0;
-  return bitmap.getColor(0, 0);
-}
-
-SkColor GetColor(cc::PaintCanvas* canvas) {
-  return GetColorAt(canvas, 0, 0);
-}
-
 // Generate frame pixels to provided |external_memory| and wrap it as frame.
 scoped_refptr<VideoFrame> CreateTestY16Frame(const gfx::Size& coded_size,
                                              const gfx::Rect& visible_rect,
                                              void* external_memory,
                                              base::TimeDelta timestamp) {
   const int offset_x = visible_rect.x();
   const int offset_y = visible_rect.y();
   const int stride = coded_size.width();
   const size_t byte_size = stride * coded_size.height() * 2;
 
@@ skipping 43 matching lines @@
             cc::PaintCanvas* canvas);
 
   // Getters for various frame sizes.
   scoped_refptr<VideoFrame> natural_frame() { return natural_frame_; }
   scoped_refptr<VideoFrame> larger_frame() { return larger_frame_; }
   scoped_refptr<VideoFrame> smaller_frame() { return smaller_frame_; }
   scoped_refptr<VideoFrame> cropped_frame() { return cropped_frame_; }
 
   // Standard canvas.
   cc::PaintCanvas* target_canvas() { return &target_canvas_; }
+  SkBitmap* bitmap() { return &bitmap_; }
 
  protected:
   SkCanvasVideoRenderer renderer_;
 
   scoped_refptr<VideoFrame> natural_frame_;
   scoped_refptr<VideoFrame> larger_frame_;
   scoped_refptr<VideoFrame> smaller_frame_;
   scoped_refptr<VideoFrame> cropped_frame_;
 
+  SkBitmap bitmap_;
   cc::SkiaPaintCanvas target_canvas_;
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SkCanvasVideoRendererTest);
 };
 
 static SkBitmap AllocBitmap(int width, int height) {
   SkBitmap bitmap;
   bitmap.allocPixels(SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType));
   bitmap.eraseColor(0);
   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(PIXEL_FORMAT_YV12,
                                   gfx::Size(16, 16),
                                   gfx::Rect(6, 6, 8, 6),
                                   gfx::Size(8, 6),
                                   base::TimeDelta::FromMilliseconds(4))),
-      target_canvas_(AllocBitmap(kWidth, kHeight)) {
+      bitmap_(AllocBitmap(kWidth, kHeight)),
+      target_canvas_(bitmap_) {
   // Give each frame a unique timestamp.
   natural_frame_->set_timestamp(base::TimeDelta::FromMilliseconds(1));
   larger_frame_->set_timestamp(base::TimeDelta::FromMilliseconds(2));
   smaller_frame_->set_timestamp(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()->visible_rect().width() * kHeight,
             cropped_frame()->visible_rect().height() * kWidth);
 
@@ skipping 116 matching lines @@
 }
 
 void SkCanvasVideoRendererTest::Copy(
     const scoped_refptr<VideoFrame>& video_frame,
     cc::PaintCanvas* canvas) {
   renderer_.Copy(video_frame, canvas, Context3D());
 }
 
 TEST_F(SkCanvasVideoRendererTest, NoFrame) {
   // Test that black gets painted over canvas.
-  FillCanvas(target_canvas(), SK_ColorRED);
+  target_canvas()->clear(SK_ColorRED);
   PaintWithoutFrame(target_canvas());
-  EXPECT_EQ(SK_ColorBLACK, GetColor(target_canvas()));
+  EXPECT_EQ(SK_ColorBLACK, bitmap()->getColor(0, 0));
 }
 
 TEST_F(SkCanvasVideoRendererTest, TransparentFrame) {
-  FillCanvas(target_canvas(), SK_ColorRED);
+  target_canvas()->clear(SK_ColorRED);
   PaintRotated(
       VideoFrame::CreateTransparentFrame(gfx::Size(kWidth, kHeight)).get(),
       target_canvas(), kNaturalRect, kNone, SkBlendMode::kSrcOver,
       VIDEO_ROTATION_0);
-  EXPECT_EQ(static_cast<SkColor>(SK_ColorRED), GetColor(target_canvas()));
+  EXPECT_EQ(static_cast<SkColor>(SK_ColorRED), bitmap()->getColor(0, 0));
 }
 
 TEST_F(SkCanvasVideoRendererTest, TransparentFrameSrcMode) {
-  FillCanvas(target_canvas(), SK_ColorRED);
+  target_canvas()->clear(SK_ColorRED);
   // SRC mode completely overwrites the buffer.
   PaintRotated(
       VideoFrame::CreateTransparentFrame(gfx::Size(kWidth, kHeight)).get(),
       target_canvas(), kNaturalRect, kNone, SkBlendMode::kSrc,
       VIDEO_ROTATION_0);
   EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
-            GetColor(target_canvas()));
+            bitmap()->getColor(0, 0));
 }
 
 TEST_F(SkCanvasVideoRendererTest, CopyTransparentFrame) {
-  FillCanvas(target_canvas(), SK_ColorRED);
+  target_canvas()->clear(SK_ColorRED);
   Copy(VideoFrame::CreateTransparentFrame(gfx::Size(kWidth, kHeight)).get(),
        target_canvas());
   EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
-            GetColor(target_canvas()));
+            bitmap()->getColor(0, 0));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Natural) {
   Paint(natural_frame(), target_canvas(), kRed);
-  EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
+  EXPECT_EQ(SK_ColorRED, bitmap()->getColor(0, 0));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Larger) {
   Paint(natural_frame(), target_canvas(), kRed);
-  EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
+  EXPECT_EQ(SK_ColorRED, bitmap()->getColor(0, 0));
 
   Paint(larger_frame(), target_canvas(), kBlue);
-  EXPECT_EQ(SK_ColorBLUE, GetColor(target_canvas()));
+  EXPECT_EQ(SK_ColorBLUE, bitmap()->getColor(0, 0));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Smaller) {
   Paint(natural_frame(), target_canvas(), kRed);
-  EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
+  EXPECT_EQ(SK_ColorRED, bitmap()->getColor(0, 0));
 
   Paint(smaller_frame(), target_canvas(), kBlue);
-  EXPECT_EQ(SK_ColorBLUE, GetColor(target_canvas()));
+  EXPECT_EQ(SK_ColorBLUE, bitmap()->getColor(0, 0));
 }
 
 TEST_F(SkCanvasVideoRendererTest, NoTimestamp) {
   VideoFrame* video_frame = natural_frame().get();
   video_frame->set_timestamp(media::kNoTimestamp);
   Paint(video_frame, target_canvas(), kRed);
-  EXPECT_EQ(SK_ColorRED, GetColor(target_canvas()));
+  EXPECT_EQ(SK_ColorRED, bitmap()->getColor(0, 0));
 }
 
 TEST_F(SkCanvasVideoRendererTest, CroppedFrame) {
   Paint(cropped_frame(), target_canvas(), kNone);
   // Check the corners.
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(target_canvas(), 0, 0));
-  EXPECT_EQ(SK_ColorRED, GetColorAt(target_canvas(), kWidth - 1, 0));
-  EXPECT_EQ(SK_ColorGREEN, GetColorAt(target_canvas(), 0, kHeight - 1));
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(target_canvas(), kWidth - 1, kHeight - 1));
+  EXPECT_EQ(SK_ColorBLACK, bitmap()->getColor(0, 0));
+  EXPECT_EQ(SK_ColorRED, bitmap()->getColor(kWidth - 1, 0));
+  EXPECT_EQ(SK_ColorGREEN, bitmap()->getColor(0, kHeight - 1));
+  EXPECT_EQ(SK_ColorBLUE, bitmap()->getColor(kWidth - 1, kHeight - 1));
   // Check the interior along the border between color regions.  Note that we're
   // bilinearly upscaling, so we'll need to take care to pick sample points that
   // are just outside the "zone of resampling".
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(target_canvas(), kWidth * 1 / 8 - 1,
-                                      kHeight * 1 / 6 - 1));
+  EXPECT_EQ(SK_ColorBLACK,
+            bitmap()->getColor(kWidth * 1 / 8 - 1, kHeight * 1 / 6 - 1));
   EXPECT_EQ(SK_ColorRED,
-            GetColorAt(target_canvas(), kWidth * 3 / 8, kHeight * 1 / 6 - 1));
+            bitmap()->getColor(kWidth * 3 / 8, kHeight * 1 / 6 - 1));
   EXPECT_EQ(SK_ColorGREEN,
-            GetColorAt(target_canvas(), kWidth * 1 / 8 - 1, kHeight * 3 / 6));
-  EXPECT_EQ(SK_ColorBLUE,
-            GetColorAt(target_canvas(), kWidth * 3 / 8, kHeight * 3 / 6));
+            bitmap()->getColor(kWidth * 1 / 8 - 1, kHeight * 3 / 6));
+  EXPECT_EQ(SK_ColorBLUE, bitmap()->getColor(kWidth * 3 / 8, kHeight * 3 / 6));
 }
 
 TEST_F(SkCanvasVideoRendererTest, CroppedFrame_NoScaling) {
-  cc::SkiaPaintCanvas canvas(AllocBitmap(kWidth, kHeight));
+  SkBitmap bitmap = AllocBitmap(kWidth, kHeight);
+  cc::SkiaPaintCanvas canvas(bitmap);
   const gfx::Rect crop_rect = cropped_frame()->visible_rect();
 
   // Force painting to a non-zero position on the destination bitmap, to check
   // if the coordinates are calculated properly.
   const int offset_x = 10;
   const int offset_y = 15;
   canvas.translate(offset_x, offset_y);
 
   // Create a destination canvas with dimensions and scale which would not
   // cause scaling.
   canvas.scale(static_cast<SkScalar>(crop_rect.width()) / kWidth,
                static_cast<SkScalar>(crop_rect.height()) / kHeight);
 
   Paint(cropped_frame(), &canvas, kNone);
 
   // Check the corners.
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, offset_x, offset_y));
+  EXPECT_EQ(SK_ColorBLACK, bitmap.getColor(offset_x, offset_y));
   EXPECT_EQ(SK_ColorRED,
-            GetColorAt(&canvas, offset_x + crop_rect.width() - 1, offset_y));
+            bitmap.getColor(offset_x + crop_rect.width() - 1, offset_y));
   EXPECT_EQ(SK_ColorGREEN,
-            GetColorAt(&canvas, offset_x, offset_y + crop_rect.height() - 1));
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, offset_x + crop_rect.width() - 1,
-                                     offset_y + crop_rect.height() - 1));
+            bitmap.getColor(offset_x, offset_y + crop_rect.height() - 1));
+  EXPECT_EQ(SK_ColorBLUE, bitmap.getColor(offset_x + crop_rect.width() - 1,
+                                          offset_y + crop_rect.height() - 1));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Rotation_90) {
-  cc::SkiaPaintCanvas canvas(AllocBitmap(kWidth, kHeight));
+  SkBitmap bitmap = AllocBitmap(kWidth, kHeight);
+  cc::SkiaPaintCanvas canvas(bitmap);
   PaintRotated(cropped_frame(), &canvas, kNaturalRect, kNone,
                SkBlendMode::kSrcOver, VIDEO_ROTATION_90);
   // Check the corners.
-  EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, 0, 0));
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth - 1, 0));
-  EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, 0, kHeight - 1));
+  EXPECT_EQ(SK_ColorGREEN, bitmap.getColor(0, 0));
+  EXPECT_EQ(SK_ColorBLACK, bitmap.getColor(kWidth - 1, 0));
+  EXPECT_EQ(SK_ColorRED, bitmap.getColor(kWidth - 1, kHeight - 1));
+  EXPECT_EQ(SK_ColorBLUE, bitmap.getColor(0, kHeight - 1));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Rotation_180) {
-  cc::SkiaPaintCanvas canvas(AllocBitmap(kWidth, kHeight));
+  SkBitmap bitmap = AllocBitmap(kWidth, kHeight);
+  cc::SkiaPaintCanvas canvas(bitmap);
   PaintRotated(cropped_frame(), &canvas, kNaturalRect, kNone,
                SkBlendMode::kSrcOver, VIDEO_ROTATION_180);
   // Check the corners.
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, 0, 0));
-  EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth - 1, 0));
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
-  EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, 0, kHeight - 1));
+  EXPECT_EQ(SK_ColorBLUE, bitmap.getColor(0, 0));
+  EXPECT_EQ(SK_ColorGREEN, bitmap.getColor(kWidth - 1, 0));
+  EXPECT_EQ(SK_ColorBLACK, bitmap.getColor(kWidth - 1, kHeight - 1));
+  EXPECT_EQ(SK_ColorRED, bitmap.getColor(0, kHeight - 1));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Rotation_270) {
-  cc::SkiaPaintCanvas canvas(AllocBitmap(kWidth, kHeight));
+  SkBitmap bitmap = AllocBitmap(kWidth, kHeight);
+  cc::SkiaPaintCanvas canvas(bitmap);
   PaintRotated(cropped_frame(), &canvas, kNaturalRect, kNone,
                SkBlendMode::kSrcOver, VIDEO_ROTATION_270);
   // Check the corners.
-  EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, 0, 0));
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth - 1, 0));
-  EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, 0, kHeight - 1));
+  EXPECT_EQ(SK_ColorRED, bitmap.getColor(0, 0));
+  EXPECT_EQ(SK_ColorBLUE, bitmap.getColor(kWidth - 1, 0));
+  EXPECT_EQ(SK_ColorGREEN, bitmap.getColor(kWidth - 1, kHeight - 1));
+  EXPECT_EQ(SK_ColorBLACK, bitmap.getColor(0, kHeight - 1));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Translate) {
-  cc::SkiaPaintCanvas canvas(AllocBitmap(kWidth, kHeight));
-  FillCanvas(&canvas, SK_ColorMAGENTA);
+  SkBitmap bitmap = AllocBitmap(kWidth, kHeight);
+  cc::SkiaPaintCanvas canvas(bitmap);
+  canvas.clear(SK_ColorMAGENTA);
 
   PaintRotated(cropped_frame(), &canvas,
                gfx::RectF(kWidth / 2, kHeight / 2, kWidth / 2, kHeight / 2),
                kNone, SkBlendMode::kSrcOver, VIDEO_ROTATION_0);
   // Check the corners of quadrant 2 and 4.
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, 0));
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, (kWidth / 2) - 1, 0));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor(0, 0));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor((kWidth / 2) - 1, 0));
   EXPECT_EQ(SK_ColorMAGENTA,
-            GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, (kHeight / 2) - 1));
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth / 2, kHeight / 2));
-  EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth - 1, kHeight / 2));
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
-  EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth / 2, kHeight - 1));
+            bitmap.getColor((kWidth / 2) - 1, (kHeight / 2) - 1));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor(0, (kHeight / 2) - 1));
+  EXPECT_EQ(SK_ColorBLACK, bitmap.getColor(kWidth / 2, kHeight / 2));
+  EXPECT_EQ(SK_ColorRED, bitmap.getColor(kWidth - 1, kHeight / 2));
+  EXPECT_EQ(SK_ColorBLUE, bitmap.getColor(kWidth - 1, kHeight - 1));
+  EXPECT_EQ(SK_ColorGREEN, bitmap.getColor(kWidth / 2, kHeight - 1));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Translate_Rotation_90) {
-  cc::SkiaPaintCanvas canvas(AllocBitmap(kWidth, kHeight));
-  FillCanvas(&canvas, SK_ColorMAGENTA);
+  SkBitmap bitmap = AllocBitmap(kWidth, kHeight);
+  cc::SkiaPaintCanvas canvas(bitmap);
+  canvas.clear(SK_ColorMAGENTA);
 
   PaintRotated(cropped_frame(), &canvas,
                gfx::RectF(kWidth / 2, kHeight / 2, kWidth / 2, kHeight / 2),
                kNone, SkBlendMode::kSrcOver, VIDEO_ROTATION_90);
   // Check the corners of quadrant 2 and 4.
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, 0));
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, (kWidth / 2) - 1, 0));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor(0, 0));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor((kWidth / 2) - 1, 0));
   EXPECT_EQ(SK_ColorMAGENTA,
-            GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, (kHeight / 2) - 1));
-  EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth / 2, kHeight / 2));
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth - 1, kHeight / 2));
-  EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth / 2, kHeight - 1));
+            bitmap.getColor((kWidth / 2) - 1, (kHeight / 2) - 1));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor(0, (kHeight / 2) - 1));
+  EXPECT_EQ(SK_ColorGREEN, bitmap.getColor(kWidth / 2, kHeight / 2));
+  EXPECT_EQ(SK_ColorBLACK, bitmap.getColor(kWidth - 1, kHeight / 2));
+  EXPECT_EQ(SK_ColorRED, bitmap.getColor(kWidth - 1, kHeight - 1));
+  EXPECT_EQ(SK_ColorBLUE, bitmap.getColor(kWidth / 2, kHeight - 1));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Translate_Rotation_180) {
-  cc::SkiaPaintCanvas canvas(AllocBitmap(kWidth, kHeight));
-  FillCanvas(&canvas, SK_ColorMAGENTA);
+  SkBitmap bitmap = AllocBitmap(kWidth, kHeight);
+  cc::SkiaPaintCanvas canvas(bitmap);
+  canvas.clear(SK_ColorMAGENTA);
 
   PaintRotated(cropped_frame(), &canvas,
                gfx::RectF(kWidth / 2, kHeight / 2, kWidth / 2, kHeight / 2),
                kNone, SkBlendMode::kSrcOver, VIDEO_ROTATION_180);
   // Check the corners of quadrant 2 and 4.
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, 0));
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, (kWidth / 2) - 1, 0));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor(0, 0));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor((kWidth / 2) - 1, 0));
   EXPECT_EQ(SK_ColorMAGENTA,
-            GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, (kHeight / 2) - 1));
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth / 2, kHeight / 2));
-  EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth - 1, kHeight / 2));
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
-  EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth / 2, kHeight - 1));
+            bitmap.getColor((kWidth / 2) - 1, (kHeight / 2) - 1));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor(0, (kHeight / 2) - 1));
+  EXPECT_EQ(SK_ColorBLUE, bitmap.getColor(kWidth / 2, kHeight / 2));
+  EXPECT_EQ(SK_ColorGREEN, bitmap.getColor(kWidth - 1, kHeight / 2));
+  EXPECT_EQ(SK_ColorBLACK, bitmap.getColor(kWidth - 1, kHeight - 1));
+  EXPECT_EQ(SK_ColorRED, bitmap.getColor(kWidth / 2, kHeight - 1));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Translate_Rotation_270) {
-  cc::SkiaPaintCanvas canvas(AllocBitmap(kWidth, kHeight));
-  FillCanvas(&canvas, SK_ColorMAGENTA);
+  SkBitmap bitmap = AllocBitmap(kWidth, kHeight);
+  cc::SkiaPaintCanvas canvas(bitmap);
+  canvas.clear(SK_ColorMAGENTA);
 
   PaintRotated(cropped_frame(), &canvas,
                gfx::RectF(kWidth / 2, kHeight / 2, kWidth / 2, kHeight / 2),
                kNone, SkBlendMode::kSrcOver, VIDEO_ROTATION_270);
   // Check the corners of quadrant 2 and 4.
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, 0));
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, (kWidth / 2) - 1, 0));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor(0, 0));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor((kWidth / 2) - 1, 0));
   EXPECT_EQ(SK_ColorMAGENTA,
-            GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
-  EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, (kHeight / 2) - 1));
-  EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth / 2, kHeight / 2));
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth - 1, kHeight / 2));
-  EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth / 2, kHeight - 1));
+            bitmap.getColor((kWidth / 2) - 1, (kHeight / 2) - 1));
+  EXPECT_EQ(SK_ColorMAGENTA, bitmap.getColor(0, (kHeight / 2) - 1));
+  EXPECT_EQ(SK_ColorRED, bitmap.getColor(kWidth / 2, kHeight / 2));
+  EXPECT_EQ(SK_ColorBLUE, bitmap.getColor(kWidth - 1, kHeight / 2));
+  EXPECT_EQ(SK_ColorGREEN, bitmap.getColor(kWidth - 1, kHeight - 1));
+  EXPECT_EQ(SK_ColorBLACK, bitmap.getColor(kWidth / 2, kHeight - 1));
 }
 
 TEST_F(SkCanvasVideoRendererTest, HighBits) {
   // Copy cropped_frame into a highbit frame.
   scoped_refptr<VideoFrame> frame(VideoFrame::CreateFrame(
       PIXEL_FORMAT_YUV420P10, cropped_frame()->coded_size(),
       cropped_frame()->visible_rect(), cropped_frame()->natural_size(),
       cropped_frame()->timestamp()));
   for (int plane = VideoFrame::kYPlane; plane <= VideoFrame::kVPlane; ++plane) {
     int width = cropped_frame()->row_bytes(plane);
     uint16_t* dst = reinterpret_cast<uint16_t*>(frame->data(plane));
     uint8_t* src = cropped_frame()->data(plane);
     for (int row = 0; row < cropped_frame()->rows(plane); row++) {
       for (int col = 0; col < width; col++) {
         dst[col] = src[col] << 2;
       }
       src += cropped_frame()->stride(plane);
       dst += frame->stride(plane) / 2;
     }
   }
 
   Paint(frame, target_canvas(), kNone);
   // Check the corners.
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(target_canvas(), 0, 0));
-  EXPECT_EQ(SK_ColorRED, GetColorAt(target_canvas(), kWidth - 1, 0));
-  EXPECT_EQ(SK_ColorGREEN, GetColorAt(target_canvas(), 0, kHeight - 1));
-  EXPECT_EQ(SK_ColorBLUE, GetColorAt(target_canvas(), kWidth - 1, kHeight - 1));
+  EXPECT_EQ(SK_ColorBLACK, bitmap()->getColor(0, 0));
+  EXPECT_EQ(SK_ColorRED, bitmap()->getColor(kWidth - 1, 0));
+  EXPECT_EQ(SK_ColorGREEN, bitmap()->getColor(0, kHeight - 1));
+  EXPECT_EQ(SK_ColorBLUE, bitmap()->getColor(kWidth - 1, kHeight - 1));
   // Check the interior along the border between color regions.  Note that we're
   // bilinearly upscaling, so we'll need to take care to pick sample points that
   // are just outside the "zone of resampling".
-  EXPECT_EQ(SK_ColorBLACK, GetColorAt(target_canvas(), kWidth * 1 / 8 - 1,
-                                      kHeight * 1 / 6 - 1));
+  EXPECT_EQ(SK_ColorBLACK,
+            bitmap()->getColor(kWidth * 1 / 8 - 1, kHeight * 1 / 6 - 1));
   EXPECT_EQ(SK_ColorRED,
-            GetColorAt(target_canvas(), kWidth * 3 / 8, kHeight * 1 / 6 - 1));
+            bitmap()->getColor(kWidth * 3 / 8, kHeight * 1 / 6 - 1));
   EXPECT_EQ(SK_ColorGREEN,
-            GetColorAt(target_canvas(), kWidth * 1 / 8 - 1, kHeight * 3 / 6));
-  EXPECT_EQ(SK_ColorBLUE,
-            GetColorAt(target_canvas(), kWidth * 3 / 8, kHeight * 3 / 6));
+            bitmap()->getColor(kWidth * 1 / 8 - 1, kHeight * 3 / 6));
+  EXPECT_EQ(SK_ColorBLUE, bitmap()->getColor(kWidth * 3 / 8, kHeight * 3 / 6));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Y16) {
   SkBitmap bitmap;
   bitmap.allocPixels(SkImageInfo::MakeN32(16, 16, kPremul_SkAlphaType));
 
   // |offset_x| and |offset_y| define visible rect's offset to coded rect.
   const int offset_x = 3;
   const int offset_y = 5;
   const int stride = bitmap.width() + offset_x;
@@ skipping 251 matching lines @@
         EXPECT_EQ(expected_value, data[(i + j * width)]);
       }
     }
   });
   SkCanvasVideoRenderer::TexSubImage2D(GL_TEXTURE_2D, &gles2, video_frame.get(),
                                        0, GL_RED, GL_FLOAT, 2 /*xoffset*/,
                                        1 /*yoffset*/, false /*flip_y*/, true);
 }
 
 }  // namespace media