Fix odd size and visible rect issues in CanvasCaptureHandler

content/renderer/media/canvas_capture_handler_unittest.cc

 // Copyright 2015 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/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/canvas_capture_handler.h"
 #include "content/renderer/media/media_stream_video_capturer_source.h"
@@ skipping 15 matching lines @@
 namespace content {
 
 namespace {
 
 static const int kTestCanvasCaptureWidth = 320;
 static const int kTestCanvasCaptureHeight = 240;
 static const double kTestCanvasCaptureFramesPerSecond = 55.5;
 
 static const int kTestCanvasCaptureFrameWidth = 2;
 static const int kTestCanvasCaptureFrameHeight = 2;
-static const int kTestCanvasCaptureFrameErrorTolerance = 2;
+static const int kTestCanvasOddSizeOffset = 1;
+static const int kTestCanvasCaptureFrameColorErrorTolerance = 2;
 static const int kTestAlphaValue = 175;
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 }  // namespace
 
-class CanvasCaptureHandlerTest : public TestWithParam<bool> {
+class CanvasCaptureHandlerTest
+    : public TestWithParam<testing::tuple<bool, bool>> {
  public:
   CanvasCaptureHandlerTest() {}
 
   void SetUp() override {
     canvas_capture_handler_.reset(
         CanvasCaptureHandler::CreateCanvasCaptureHandler(
             blink::WebSize(kTestCanvasCaptureWidth, kTestCanvasCaptureHeight),
             kTestCanvasCaptureFramesPerSecond, message_loop_.task_runner(),
             &track_));
   }
@@ skipping 18 matching lines @@
   MOCK_METHOD1(DoOnVideoCaptureDeviceFormats,
                void(const media::VideoCaptureFormats&));
   void OnVideoCaptureDeviceFormats(const media::VideoCaptureFormats& formats) {
     DoOnVideoCaptureDeviceFormats(formats);
   }
 
   MOCK_METHOD1(DoOnRunning, void(bool));
   void OnRunning(bool state) { DoOnRunning(state); }
 
   // Verify returned frames.
-  static sk_sp<SkImage> GenerateTestImage(bool opaque) {
-
+  static sk_sp<SkImage> GenerateTestImage(bool opaque, bool odd_size) {
     SkBitmap testBitmap;
-    testBitmap.allocN32Pixels(kTestCanvasCaptureFrameWidth,
-                              kTestCanvasCaptureFrameHeight, opaque);
+    const int offset = odd_size ? kTestCanvasOddSizeOffset : 0;

[mcasas, 2016/04/26 00:07:14]

I'd say: Just use an integer parameter for the test (call it
|extra_misalignment| or something like that here)
as a test parameter and avoid the extra conversions.

[emircan, 2016/04/26 19:47:07]

Done.

+    testBitmap.allocN32Pixels(kTestCanvasCaptureFrameWidth + offset,
+                              kTestCanvasCaptureFrameHeight + offset, opaque);
     testBitmap.eraseARGB(kTestAlphaValue, 30, 60, 200);
     return SkImage::MakeFromBitmap(testBitmap);
   }
 
   void OnVerifyDeliveredFrame(
       bool opaque,
+      bool odd_size,
       const scoped_refptr<media::VideoFrame>& video_frame,
       base::TimeTicks estimated_capture_time) {
     if (opaque)
       EXPECT_EQ(media::PIXEL_FORMAT_I420, video_frame->format());
     else
       EXPECT_EQ(media::PIXEL_FORMAT_YV12A, video_frame->format());
 
     EXPECT_EQ(video_frame->timestamp().InMilliseconds(),
               (estimated_capture_time - base::TimeTicks()).InMilliseconds());
-    const gfx::Size& size = video_frame->coded_size();
-    EXPECT_EQ(kTestCanvasCaptureFrameWidth, size.width());
-    EXPECT_EQ(kTestCanvasCaptureFrameHeight, size.height());
-    const uint8_t* y_plane = video_frame->data(media::VideoFrame::kYPlane);
-    EXPECT_NEAR(74, y_plane[0], kTestCanvasCaptureFrameErrorTolerance);
-    const uint8_t* u_plane = video_frame->data(media::VideoFrame::kUPlane);
-    EXPECT_NEAR(193, u_plane[0], kTestCanvasCaptureFrameErrorTolerance);
-    const uint8_t* v_plane = video_frame->data(media::VideoFrame::kVPlane);
-    EXPECT_NEAR(105, v_plane[0], kTestCanvasCaptureFrameErrorTolerance);
+    const int offset = odd_size ? kTestCanvasOddSizeOffset : 0;
+    const gfx::Size& size = video_frame->visible_rect().size();
+    EXPECT_EQ(kTestCanvasCaptureFrameWidth + offset, size.width());
+    EXPECT_EQ(kTestCanvasCaptureFrameHeight + offset, size.height());
+    const uint8_t* y_plane =
+        video_frame->visible_data(media::VideoFrame::kYPlane);
+    EXPECT_NEAR(74, y_plane[0], kTestCanvasCaptureFrameColorErrorTolerance);
+    const uint8_t* u_plane =
+        video_frame->visible_data(media::VideoFrame::kUPlane);
+    EXPECT_NEAR(193, u_plane[0], kTestCanvasCaptureFrameColorErrorTolerance);
+    const uint8_t* v_plane =
+        video_frame->visible_data(media::VideoFrame::kVPlane);
+    EXPECT_NEAR(105, v_plane[0], kTestCanvasCaptureFrameColorErrorTolerance);
     if (!opaque) {
-      const uint8_t* a_plane = video_frame->data(media::VideoFrame::kAPlane);
+      const uint8_t* a_plane =
+          video_frame->visible_data(media::VideoFrame::kAPlane);
       EXPECT_EQ(kTestAlphaValue, a_plane[0]);
     }
   }
 
   blink::WebMediaStreamTrack track_;
   // The Class under test. Needs to be scoped_ptr to force its destruction.
   std::unique_ptr<CanvasCaptureHandler> canvas_capture_handler_;
 
  protected:
   media::VideoCapturerSource* GetVideoCapturerSource(
@@ skipping 61 matching lines @@
   base::RunLoop run_loop;
   base::Closure quit_closure = run_loop.QuitClosure();
   EXPECT_CALL(*this, DoOnRunning(true)).Times(1);
   EXPECT_CALL(*this, DoOnDeliverFrame(_, _))
       .Times(1)
       .WillOnce(RunClosure(quit_closure));
   source->StartCapture(
       params, base::Bind(&CanvasCaptureHandlerTest::OnDeliverFrame,
                          base::Unretained(this)),
       base::Bind(&CanvasCaptureHandlerTest::OnRunning, base::Unretained(this)));
-  canvas_capture_handler_->sendNewFrame(GenerateTestImage(GetParam()).get());
+  canvas_capture_handler_->sendNewFrame(GenerateTestImage(
+      testing::get<0>(GetParam()), testing::get<1>(GetParam())).get());
   run_loop.Run();
 
   source->StopCapture();
 }
 
 // Verifies that SkImage is processed and produces VideoFrame as expected.
-TEST_P(CanvasCaptureHandlerTest, VerifyOpaqueFrame) {
-  const bool isOpaque = GetParam();
+TEST_P(CanvasCaptureHandlerTest, VerifyFrame) {
+  const bool opaque_frame = testing::get<0>(GetParam());
+  const bool odd_size_frame = testing::get<1>(GetParam());
   InSequence s;
   media::VideoCapturerSource* const source =
       GetVideoCapturerSource(static_cast<MediaStreamVideoCapturerSource*>(
           track_.source().getExtraData()));
   EXPECT_TRUE(source != nullptr);
 
   base::RunLoop run_loop;
   EXPECT_CALL(*this, DoOnRunning(true)).Times(1);
   media::VideoCaptureParams params;
   source->StartCapture(
       params, base::Bind(&CanvasCaptureHandlerTest::OnVerifyDeliveredFrame,
-                         base::Unretained(this), isOpaque),
+                         base::Unretained(this), opaque_frame, odd_size_frame),
       base::Bind(&CanvasCaptureHandlerTest::OnRunning, base::Unretained(this)));
-  canvas_capture_handler_->sendNewFrame(GenerateTestImage(isOpaque).get());
+  canvas_capture_handler_->sendNewFrame(
+      GenerateTestImage(opaque_frame, odd_size_frame).get());
   run_loop.RunUntilIdle();
 }
 
 // Checks that needsNewFrame() works as expected.
 TEST_F(CanvasCaptureHandlerTest, CheckNeedsNewFrame) {
   InSequence s;
   media::VideoCapturerSource* source =
       GetVideoCapturerSource(static_cast<MediaStreamVideoCapturerSource*>(
           track_.source().getExtraData()));
   EXPECT_TRUE(source != nullptr);
   EXPECT_TRUE(canvas_capture_handler_->needsNewFrame());
   source->StopCapture();
   EXPECT_FALSE(canvas_capture_handler_->needsNewFrame());
 }
 
-INSTANTIATE_TEST_CASE_P(, CanvasCaptureHandlerTest, ::testing::Bool());
+INSTANTIATE_TEST_CASE_P(,
+                        CanvasCaptureHandlerTest,
+                        ::testing::Combine(::testing::Bool(),
+                                           ::testing::Bool()));
 
 }  // namespace content