Remove uses of skia::GetWritablePixels(PaintCanvas)

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"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_flags.h"
+#include "cc/paint/paint_surface.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface_stub.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libyuv/include/libyuv/convert.h"
-#include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
-#include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 #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(SkCanvas* canvas, SkColor color) {
+void FillCanvas(cc::PaintCanvas* canvas, SkColor color) {
   canvas->clear(color);
 }
 
 // Helper for returning the color of a solid |canvas|.
-SkColor GetColorAt(SkCanvas* canvas, int x, int y) {
+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(SkCanvas* canvas) {
+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();
@@ skipping 21 matching lines @@
     kNone,
     kRed,
     kGreen,
     kBlue,
   };
 
   SkCanvasVideoRendererTest();
   ~SkCanvasVideoRendererTest() override;
 
   // Paints to |canvas| using |renderer_| without any frame data.
-  void PaintWithoutFrame(SkCanvas* canvas);
+  void PaintWithoutFrame(cc::PaintCanvas* canvas);
 
   // Paints the |video_frame| to the |canvas| using |renderer_|, setting the
   // color of |video_frame| to |color| first.
   void Paint(const scoped_refptr<VideoFrame>& video_frame,
-             SkCanvas* canvas,
+             cc::PaintCanvas* canvas,
              Color color);
   void PaintRotated(const scoped_refptr<VideoFrame>& video_frame,
-                    SkCanvas* canvas,
+                    cc::PaintCanvas* canvas,
                     const gfx::RectF& dest_rect,
                     Color color,
                     SkBlendMode mode,
                     VideoRotation video_rotation);
 
-  void Copy(const scoped_refptr<VideoFrame>& video_frame, SkCanvas* canvas);
+  void Copy(const scoped_refptr<VideoFrame>& video_frame,
+            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.
-  SkCanvas* target_canvas() { return &target_canvas_; }
+  cc::PaintCanvas* target_canvas() { return &target_canvas_; }
 
  protected:
   SkCanvasVideoRenderer renderer_;
 
   scoped_refptr<VideoFrame> natural_frame_;
   scoped_refptr<VideoFrame> larger_frame_;
   scoped_refptr<VideoFrame> smaller_frame_;
   scoped_refptr<VideoFrame> cropped_frame_;
 
-  SkCanvas target_canvas_;
+  cc::PaintCanvas 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;
@@ skipping 91 matching lines @@
                    cropped_frame()->data(VideoFrame::kYPlane),
                    cropped_frame()->stride(VideoFrame::kYPlane),
                    cropped_frame()->data(VideoFrame::kUPlane),
                    cropped_frame()->stride(VideoFrame::kUPlane),
                    cropped_frame()->data(VideoFrame::kVPlane),
                    cropped_frame()->stride(VideoFrame::kVPlane), 16, 16);
 }
 
 SkCanvasVideoRendererTest::~SkCanvasVideoRendererTest() {}
 
-void SkCanvasVideoRendererTest::PaintWithoutFrame(SkCanvas* canvas) {
-  SkPaint paint;
-  paint.setFilterQuality(kLow_SkFilterQuality);
-  renderer_.Paint(nullptr, canvas, kNaturalRect, paint, VIDEO_ROTATION_0,
+void SkCanvasVideoRendererTest::PaintWithoutFrame(cc::PaintCanvas* canvas) {
+  cc::PaintFlags flags;
+  flags.setFilterQuality(kLow_SkFilterQuality);
+  renderer_.Paint(nullptr, canvas, kNaturalRect, flags, VIDEO_ROTATION_0,
                   Context3D());
 }
 
 void SkCanvasVideoRendererTest::Paint(
     const scoped_refptr<VideoFrame>& video_frame,
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     Color color) {
   PaintRotated(video_frame, canvas, kNaturalRect, color, SkBlendMode::kSrcOver,
                VIDEO_ROTATION_0);
 }
 
 void SkCanvasVideoRendererTest::PaintRotated(
     const scoped_refptr<VideoFrame>& video_frame,
-    SkCanvas* canvas,
+    cc::PaintCanvas* canvas,
     const gfx::RectF& dest_rect,
     Color color,
     SkBlendMode mode,
     VideoRotation video_rotation) {
   switch (color) {
     case kNone:
       break;
     case kRed:
       media::FillYUV(video_frame.get(), 76, 84, 255);
       break;
     case kGreen:
       media::FillYUV(video_frame.get(), 149, 43, 21);
       break;
     case kBlue:
       media::FillYUV(video_frame.get(), 29, 255, 107);
       break;
   }
-  SkPaint paint;
-  paint.setBlendMode(mode);
-  paint.setFilterQuality(kLow_SkFilterQuality);
-  renderer_.Paint(video_frame, canvas, dest_rect, paint, video_rotation,
+  cc::PaintFlags flags;
+  flags.setBlendMode(mode);
+  flags.setFilterQuality(kLow_SkFilterQuality);
+  renderer_.Paint(video_frame, canvas, dest_rect, flags, video_rotation,
                   Context3D());
 }
 
 void SkCanvasVideoRendererTest::Copy(
     const scoped_refptr<VideoFrame>& video_frame,
-    SkCanvas* canvas) {
+    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);
   PaintWithoutFrame(target_canvas());
   EXPECT_EQ(SK_ColorBLACK, GetColor(target_canvas()));
 }
 
@@ skipping 67 matching lines @@
                                       kHeight * 1 / 6 - 1));
   EXPECT_EQ(SK_ColorRED,
             GetColorAt(target_canvas(), 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));
 }
 
 TEST_F(SkCanvasVideoRendererTest, CroppedFrame_NoScaling) {
-  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+  cc::PaintCanvas canvas(AllocBitmap(kWidth, kHeight));
   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_ColorRED,
             GetColorAt(&canvas, 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));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Rotation_90) {
-  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+  cc::PaintCanvas canvas(AllocBitmap(kWidth, kHeight));
   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));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Rotation_180) {
-  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+  cc::PaintCanvas canvas(AllocBitmap(kWidth, kHeight));
   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));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Rotation_270) {
-  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+  cc::PaintCanvas canvas(AllocBitmap(kWidth, kHeight));
   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));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Translate) {
-  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+  cc::PaintCanvas canvas(AllocBitmap(kWidth, kHeight));
   FillCanvas(&canvas, 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,
             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));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Translate_Rotation_90) {
-  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+  cc::PaintCanvas canvas(AllocBitmap(kWidth, kHeight));
   FillCanvas(&canvas, 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,
             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));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Translate_Rotation_180) {
-  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+  cc::PaintCanvas canvas(AllocBitmap(kWidth, kHeight));
   FillCanvas(&canvas, 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,
             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));
 }
 
 TEST_F(SkCanvasVideoRendererTest, Video_Translate_Rotation_270) {
-  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+  cc::PaintCanvas canvas(AllocBitmap(kWidth, kHeight));
   FillCanvas(&canvas, 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,
             GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
@@ skipping 52 matching lines @@
   const int stride = bitmap.width() + offset_x;
   const size_t byte_size = stride * (bitmap.height() + offset_y) * 2;
   std::unique_ptr<unsigned char, base::AlignedFreeDeleter> memory(
       static_cast<unsigned char*>(base::AlignedAlloc(
           byte_size, media::VideoFrame::kFrameAddressAlignment)));
   const gfx::Rect rect(offset_x, offset_y, bitmap.width(), bitmap.height());
   scoped_refptr<media::VideoFrame> video_frame =
       CreateTestY16Frame(gfx::Size(stride, offset_y + bitmap.height()), rect,
                          memory.get(), cropped_frame()->timestamp());
 
-  SkCanvas canvas(bitmap);
-  SkPaint paint;
-  paint.setFilterQuality(kNone_SkFilterQuality);
+  cc::PaintCanvas canvas(bitmap);
+  cc::PaintFlags flags;
+  flags.setFilterQuality(kNone_SkFilterQuality);
   renderer_.Paint(video_frame, &canvas,
-                  gfx::RectF(bitmap.width(), bitmap.height()), paint,
+                  gfx::RectF(bitmap.width(), bitmap.height()), flags,
                   VIDEO_ROTATION_0, Context3D());
   SkAutoLockPixels lock(bitmap);
   for (int j = 0; j < bitmap.height(); j++) {
     for (int i = 0; i < bitmap.width(); i++) {
       const int value = i + j * bitmap.width();
       EXPECT_EQ(SkColorSetRGB(value, value, value), bitmap.getColor(i, j));
     }
   }
 }
 
@@ skipping 62 matching lines @@
 
 // Test that SkCanvasVideoRendererTest::Paint doesn't crash when GrContext is
 // abandoned.
 TEST_F(SkCanvasVideoRendererTest, ContextLost) {
   sk_sp<const GrGLInterface> null_interface(GrGLCreateNullInterface());
   sk_sp<GrContext> gr_context(GrContext::Create(
       kOpenGL_GrBackend,
       reinterpret_cast<GrBackendContext>(null_interface.get())));
   gr_context->abandonContext();
 
-  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+  cc::PaintCanvas canvas(AllocBitmap(kWidth, kHeight));
 
   TestGLES2Interface gles2;
   Context3D context_3d(&gles2, gr_context.get());
   gfx::Size size(kWidth, kHeight);
   gpu::MailboxHolder holders[VideoFrame::kMaxPlanes] = {gpu::MailboxHolder(
       gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_RECTANGLE_ARB)};
   auto video_frame = VideoFrame::WrapNativeTextures(
       PIXEL_FORMAT_UYVY, holders, base::Bind(MailboxHoldersReleased), size,
       gfx::Rect(size), size, kNoTimestamp);
 
-  SkPaint paint;
-  paint.setFilterQuality(kLow_SkFilterQuality);
-  renderer_.Paint(video_frame, &canvas, kNaturalRect, paint, VIDEO_ROTATION_90,
+  cc::PaintFlags flags;
+  flags.setFilterQuality(kLow_SkFilterQuality);
+  renderer_.Paint(video_frame, &canvas, kNaturalRect, flags, VIDEO_ROTATION_90,
                   context_3d);
 }
 
 void EmptyCallback(const gpu::SyncToken& sync_token) {}
 
 TEST_F(SkCanvasVideoRendererTest, CorrectFrameSizeToVisibleRect) {
   int fWidth{16}, fHeight{16};
   SkImageInfo imInfo =
       SkImageInfo::MakeN32(fWidth, fHeight, kOpaque_SkAlphaType);
 
   sk_sp<const GrGLInterface> glInterface(GrGLCreateNullInterface());
   sk_sp<GrContext> grContext(
       GrContext::Create(kOpenGL_GrBackend,
                         reinterpret_cast<GrBackendContext>(glInterface.get())));
 
-  sk_sp<SkSurface> skSurface =
-      SkSurface::MakeRenderTarget(grContext.get(), SkBudgeted::kYes, imInfo);
-  SkCanvas* canvas = skSurface->getCanvas();
+  sk_sp<cc::PaintSurface> surface = cc::PaintSurface::MakeRenderTarget(
+      grContext.get(), SkBudgeted::kYes, imInfo);
+  cc::PaintCanvas* canvas = surface->getCanvas();
 
   TestGLES2Interface gles2;
   Context3D context_3d(&gles2, grContext.get());
   gfx::Size coded_size(fWidth, fHeight);
   gfx::Size visible_size(fWidth / 2, fHeight / 2);
 
   gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes];
   for (size_t i = 0; i < VideoFrame::kMaxPlanes; i++) {
     mailbox_holders[i] = gpu::MailboxHolder(
         gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_RECTANGLE_ARB);
   }
 
   auto video_frame = VideoFrame::WrapNativeTextures(
       PIXEL_FORMAT_I420, mailbox_holders, base::Bind(EmptyCallback), coded_size,
       gfx::Rect(visible_size), visible_size,
       base::TimeDelta::FromMilliseconds(4));
 
   gfx::RectF visible_rect(visible_size.width(), visible_size.height());
-  SkPaint paint;
-  renderer_.Paint(video_frame, canvas, visible_rect, paint, VIDEO_ROTATION_0,
+  cc::PaintFlags flags;
+  renderer_.Paint(video_frame, canvas, visible_rect, flags, VIDEO_ROTATION_0,
                   context_3d);
 
   EXPECT_EQ(fWidth / 2, renderer_.LastImageDimensionsForTesting().width());
   EXPECT_EQ(fWidth / 2, renderer_.LastImageDimensionsForTesting().height());
 }
 
 TEST_F(SkCanvasVideoRendererTest, TexImage2D_Y16_RGBA32F) {
   // Create test frame.
   // |offset_x| and |offset_y| define visible rect's offset to coded rect.
   const int offset_x = 3;
@@ skipping 93 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