New static method I420Buffer::SetToBlack.

webrtc/media/base/videoframe_unittest.h

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 236 matching lines @@
         rgb[g_pos] = (x % 63 + y % 63) + 96;
         rgb[b_pos] = ((y / 63) & 1) ? 224 : 32;
         ms->Write(rgb, bytes, NULL, NULL);
       }
     }
     return ms.release();
   }
 
   // Simple conversion routines to verify the optimized VideoFrame routines.
   // Converts from the specified colorspace to I420.
-  bool ConvertYuv422(const rtc::MemoryStream* ms,
-                     uint32_t fourcc,
-                     uint32_t width,
-                     uint32_t height,
-                     T* frame) {
+  std::unique_ptr<T> ConvertYuv422(const rtc::MemoryStream* ms,
+                                   uint32_t fourcc,
+                                   uint32_t width,
+                                   uint32_t height) {
     int y1_pos, y2_pos, u_pos, v_pos;
     if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) {
-      return false;
+      return nullptr;
     }
 
+    rtc::scoped_refptr<webrtc::I420Buffer> buffer(
+        new rtc::RefCountedObject<webrtc::I420Buffer>(width, height));
+
+    buffer->SetToBlack();
+
     const uint8_t* start = reinterpret_cast<const uint8_t*>(ms->GetBuffer());
     int awidth = (width + 1) & ~1;
-    frame->InitToBlack(width, height, 0);
-    int stride_y = frame->video_frame_buffer()->StrideY();
-    int stride_u = frame->video_frame_buffer()->StrideU();
-    int stride_v = frame->video_frame_buffer()->StrideV();
-    uint8_t* plane_y = frame->video_frame_buffer()->MutableDataY();
-    uint8_t* plane_u = frame->video_frame_buffer()->MutableDataU();
-    uint8_t* plane_v = frame->video_frame_buffer()->MutableDataV();
+    int stride_y = buffer->StrideY();
+    int stride_u = buffer->StrideU();
+    int stride_v = buffer->StrideV();
+    uint8_t* plane_y = buffer->MutableDataY();
+    uint8_t* plane_u = buffer->MutableDataU();
+    uint8_t* plane_v = buffer->MutableDataV();
     for (uint32_t y = 0; y < height; ++y) {
       for (uint32_t x = 0; x < width; x += 2) {
         const uint8_t* quad1 = start + (y * awidth + x) * 2;
         plane_y[stride_y * y + x] = quad1[y1_pos];
         if ((x + 1) < width) {
           plane_y[stride_y * y + x + 1] = quad1[y2_pos];
         }
         if ((y & 1) == 0) {
           const uint8_t* quad2 = quad1 + awidth * 2;
           if ((y + 1) >= height) {
             quad2 = quad1;
           }
           plane_u[stride_u * (y / 2) + x / 2] =
               (quad1[u_pos] + quad2[u_pos] + 1) / 2;
           plane_v[stride_v * (y / 2) + x / 2] =
               (quad1[v_pos] + quad2[v_pos] + 1) / 2;
         }
       }
     }
-    return true;
+    return std::unique_ptr<T>(new T(buffer, 0, webrtc::kVideoRotation_0));
   }
 
   // Convert RGB to 420.
   // A negative height inverts the image.
-  bool ConvertRgb(const rtc::MemoryStream* ms,
-                  uint32_t fourcc,
-                  int32_t width,
-                  int32_t height,
-                  T* frame) {
+  std::unique_ptr<T> ConvertRgb(const rtc::MemoryStream* ms,
+                                uint32_t fourcc,
+                                int32_t width,
+                                int32_t height) {
     int r_pos, g_pos, b_pos, bytes;
     if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
-      return false;
+      return nullptr;
     }
     int pitch = width * bytes;
     const uint8_t* start = reinterpret_cast<const uint8_t*>(ms->GetBuffer());
     if (height < 0) {
       height = -height;
       start = start + pitch * (height - 1);
       pitch = -pitch;
     }
-    frame->InitToBlack(width, height, 0);
-    int stride_y = frame->video_frame_buffer()->StrideY();
-    int stride_u = frame->video_frame_buffer()->StrideU();
-    int stride_v = frame->video_frame_buffer()->StrideV();
-    uint8_t* plane_y = frame->video_frame_buffer()->MutableDataY();
-    uint8_t* plane_u = frame->video_frame_buffer()->MutableDataU();
-    uint8_t* plane_v = frame->video_frame_buffer()->MutableDataV();
+    rtc::scoped_refptr<webrtc::I420Buffer> buffer(
+        new rtc::RefCountedObject<webrtc::I420Buffer>(width, height));
+
+    buffer->SetToBlack();
+
+    int stride_y = buffer->StrideY();
+    int stride_u = buffer->StrideU();
+    int stride_v = buffer->StrideV();
+    uint8_t* plane_y = buffer->MutableDataY();
+    uint8_t* plane_u = buffer->MutableDataU();
+    uint8_t* plane_v = buffer->MutableDataV();
     for (int32_t y = 0; y < height; y += 2) {
       for (int32_t x = 0; x < width; x += 2) {
         const uint8_t* rgb[4];
         uint8_t yuv[4][3];
         rgb[0] = start + y * pitch + x * bytes;
         rgb[1] = rgb[0] + ((x + 1) < width ? bytes : 0);
         rgb[2] = rgb[0] + ((y + 1) < height ? pitch : 0);
         rgb[3] = rgb[2] + ((x + 1) < width ? bytes : 0);
         for (size_t i = 0; i < 4; ++i) {
           ConvertRgbPixel(rgb[i][r_pos], rgb[i][g_pos], rgb[i][b_pos],
                           &yuv[i][0], &yuv[i][1], &yuv[i][2]);
         }
         plane_y[stride_y * y + x] = yuv[0][0];
         if ((x + 1) < width) {
           plane_y[stride_y * y + x + 1] = yuv[1][0];
         }
         if ((y + 1) < height) {
           plane_y[stride_y * (y + 1) + x] = yuv[2][0];
           if ((x + 1) < width) {
             plane_y[stride_y * (y + 1) + x + 1] = yuv[3][0];
           }
         }
         plane_u[stride_u * (y / 2) + x / 2] =
             (yuv[0][1] + yuv[1][1] + yuv[2][1] + yuv[3][1] + 2) / 4;
         plane_v[stride_v * (y / 2) + x / 2] =
             (yuv[0][2] + yuv[1][2] + yuv[2][2] + yuv[3][2] + 2) / 4;
       }
     }
-    return true;
+    return std::unique_ptr<T>(new T(buffer, 0, webrtc::kVideoRotation_0));
   }
 
   // Simple and slow RGB->YUV conversion. From NTSC standard, c/o Wikipedia.
   void ConvertRgbPixel(uint8_t r,
                        uint8_t g,
                        uint8_t b,
                        uint8_t* y,
                        uint8_t* u,
                        uint8_t* v) {
     *y = static_cast<int>(.257 * r + .504 * g + .098 * b) + 16;
@@ skipping 137 matching lines @@
                    frame2.video_frame_buffer()->StrideU(),
                    frame2.video_frame_buffer()->DataV()
                        + vcrop * frame2.video_frame_buffer()->StrideV() / 2
                        + hcrop / 2,
                    frame2.video_frame_buffer()->StrideV(),
                    max_error);
   }
 
   static bool IsBlack(const cricket::VideoFrame& frame) {
     return !IsNull(frame) &&
-           *frame.video_frame_buffer()->DataY() == 16 &&
+           *frame.video_frame_buffer()->DataY() <= 16 &&
            *frame.video_frame_buffer()->DataU() == 128 &&
            *frame.video_frame_buffer()->DataV() == 128;
   }
 
   ////////////////////////
   // Construction tests //
   ////////////////////////
 
   // Test constructing an image from a I420 buffer.
   void ConstructI420() {
@@ skipping 86 matching lines @@
                                     yuy2, kWidth * 2,
                                     kWidth, kHeight));
     EXPECT_TRUE(LoadFrame(yuy2, buf_size, cricket::FOURCC_YUY2,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
   }
 
   // Test constructing an image from a wide YUY2 buffer.
   // Normal is 1280x720.  Wide is 12800x72
   void ConstructYuy2Wide() {
-    T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth * 10, kHeight / 10));
     ASSERT_TRUE(ms.get() != NULL);
-    EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2,
-                              kWidth * 10, kHeight / 10,
-                              &frame1));
+    std::unique_ptr<T> frame1 = ConvertYuv422(ms.get(), cricket::FOURCC_YUY2,
+                                              kWidth * 10, kHeight / 10);
+    ASSERT_TRUE(frame1);
+    T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2,
                           kWidth * 10, kHeight / 10, &frame2));
-    EXPECT_TRUE(IsEqual(frame1, frame2, 0));
+    EXPECT_TRUE(IsEqual(*frame1, frame2, 0));
   }
 
   // Test constructing an image from a UYVY buffer.
   void ConstructUyvy() {
-    T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
-    EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_UYVY, kWidth, kHeight,
-                              &frame1));
+    std::unique_ptr<T> frame1 = ConvertYuv422(ms.get(), cricket::FOURCC_UYVY,
+                                              kWidth, kHeight);
+    T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY,
                           kWidth, kHeight, &frame2));
-    EXPECT_TRUE(IsEqual(frame1, frame2, 0));
+    EXPECT_TRUE(IsEqual(*frame1, frame2, 0));
   }
 
   // Test constructing an image from a random buffer.
   // We are merely verifying that the code succeeds and is free of crashes.
   void ConstructM420() {
     T frame;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_M420,
@@ skipping 14 matching lines @@
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_NV12,
                           kWidth, kHeight, &frame));
   }
 
   // Test constructing an image from a ABGR buffer
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void ConstructABGR() {
-    T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ABGR, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
-    EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ABGR, kWidth, kHeight,
-                           &frame1));
+    std::unique_ptr<T> frame1 = ConvertRgb(ms.get(), cricket::FOURCC_ABGR,
+                                           kWidth, kHeight);
+    ASSERT_TRUE(frame1);
+    T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ABGR,
                           kWidth, kHeight, &frame2));
-    EXPECT_TRUE(IsEqual(frame1, frame2, 2));
+    EXPECT_TRUE(IsEqual(*frame1, frame2, 2));
   }
 
   // Test constructing an image from a ARGB buffer
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void ConstructARGB() {
-    T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
-    EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight,
-                           &frame1));
+    std::unique_ptr<T> frame1 = ConvertRgb(ms.get(), cricket::FOURCC_ARGB,
+                                           kWidth, kHeight);
+    ASSERT_TRUE(frame1);
+    T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB,
                           kWidth, kHeight, &frame2));
-    EXPECT_TRUE(IsEqual(frame1, frame2, 2));
+    EXPECT_TRUE(IsEqual(*frame1, frame2, 2));
   }
 
   // Test constructing an image from a wide ARGB buffer
   // Normal is 1280x720.  Wide is 12800x72
   void ConstructARGBWide() {
-    T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth * 10, kHeight / 10));
     ASSERT_TRUE(ms.get() != NULL);
-    EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB,
-                           kWidth * 10, kHeight / 10, &frame1));
+    std::unique_ptr<T> frame1 = ConvertRgb(ms.get(), cricket::FOURCC_ARGB,
+                                           kWidth * 10, kHeight / 10);
+    ASSERT_TRUE(frame1);
+    T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB,
                           kWidth * 10, kHeight / 10, &frame2));
-    EXPECT_TRUE(IsEqual(frame1, frame2, 2));
+    EXPECT_TRUE(IsEqual(*frame1, frame2, 2));
   }
 
   // Test constructing an image from an BGRA buffer.
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void ConstructBGRA() {
-    T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_BGRA, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
-    EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_BGRA, kWidth, kHeight,
-                           &frame1));
+    std::unique_ptr<T> frame1 = ConvertRgb(ms.get(), cricket::FOURCC_BGRA,
+                                           kWidth, kHeight);
+    ASSERT_TRUE(frame1);
+    T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_BGRA,
                           kWidth, kHeight, &frame2));
-    EXPECT_TRUE(IsEqual(frame1, frame2, 2));
+    EXPECT_TRUE(IsEqual(*frame1, frame2, 2));
   }
 
   // Test constructing an image from a 24BG buffer.
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void Construct24BG() {
-    T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_24BG, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
-    EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_24BG, kWidth, kHeight,
-                           &frame1));
+    std::unique_ptr<T> frame1 = ConvertRgb(ms.get(), cricket::FOURCC_24BG,
+                                           kWidth, kHeight);
+    ASSERT_TRUE(frame1);
+    T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_24BG,
                           kWidth, kHeight, &frame2));
-    EXPECT_TRUE(IsEqual(frame1, frame2, 2));
+    EXPECT_TRUE(IsEqual(*frame1, frame2, 2));
   }
 
   // Test constructing an image from a raw RGB buffer.
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void ConstructRaw() {
-    T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_RAW, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
-    EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_RAW, kWidth, kHeight,
-                           &frame1));
+    std::unique_ptr<T> frame1 = ConvertRgb(ms.get(), cricket::FOURCC_RAW,
+                                           kWidth, kHeight);
+    ASSERT_TRUE(frame1);
+    T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_RAW,
                           kWidth, kHeight, &frame2));
-    EXPECT_TRUE(IsEqual(frame1, frame2, 2));
+    EXPECT_TRUE(IsEqual(*frame1, frame2, 2));
   }
 
   // Test constructing an image from a RGB565 buffer
   void ConstructRGB565() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
     std::unique_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
     uint8_t* out = ALIGNP(outbuf.get(), kAlignment);
     T frame;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
@@ skipping 49 matching lines @@
                           webrtc::kVideoRotation_180, &frame1));               \
     size_t data_size;                                                          \
     bool ret = ms->GetSize(&data_size);                                        \
     EXPECT_TRUE(ret);                                                          \
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, kWidth, kHeight, kWidth, \
                             kHeight,                                           \
                             reinterpret_cast<uint8_t*>(ms->GetBuffer()),       \
                             data_size, 0, webrtc::kVideoRotation_0));          \
     int width_rotate = frame1.width();                                         \
     int height_rotate = frame1.height();                                       \
-    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 0));           \
+    frame3.InitToEmptyBuffer(width_rotate, height_rotate, 0);                  \
     libyuv::I420Mirror(frame2.video_frame_buffer()->DataY(),                   \
                        frame2.video_frame_buffer()->StrideY(),                 \
                        frame2.video_frame_buffer()->DataU(),                   \
                        frame2.video_frame_buffer()->StrideU(),                 \
                        frame2.video_frame_buffer()->DataV(),                   \
                        frame2.video_frame_buffer()->StrideV(),                 \
                        frame3.video_frame_buffer()->MutableDataY(),            \
                        frame3.video_frame_buffer()->StrideY(),                 \
                        frame3.video_frame_buffer()->MutableDataU(),            \
                        frame3.video_frame_buffer()->StrideU(),                 \
@@ skipping 17 matching lines @@
                           &frame1));                                           \
     size_t data_size;                                                          \
     bool ret = ms->GetSize(&data_size);                                        \
     EXPECT_TRUE(ret);                                                          \
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, kWidth, kHeight, kWidth, \
                             kHeight,                                           \
                             reinterpret_cast<uint8_t*>(ms->GetBuffer()),       \
                             data_size, 0, webrtc::kVideoRotation_0));          \
     int width_rotate = frame1.width();                                         \
     int height_rotate = frame1.height();                                       \
-    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 0));           \
+    frame3.InitToEmptyBuffer(width_rotate, height_rotate, 0);                  \
     libyuv::I420Rotate(frame2.video_frame_buffer()->DataY(),                   \
                        frame2.video_frame_buffer()->StrideY(),                 \
                        frame2.video_frame_buffer()->DataU(),                   \
                        frame2.video_frame_buffer()->StrideU(),                 \
                        frame2.video_frame_buffer()->DataV(),                   \
                        frame2.video_frame_buffer()->StrideV(),                 \
                        frame3.video_frame_buffer()->MutableDataY(),            \
                        frame3.video_frame_buffer()->StrideY(),                 \
                        frame3.video_frame_buffer()->MutableDataU(),            \
                        frame3.video_frame_buffer()->StrideU(),                 \
@@ skipping 203 matching lines @@
     EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight,
                               &frame1));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight,
                           kWidth * 3 / 4, kHeight, webrtc::kVideoRotation_0,
                           &frame2));
     EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, kWidth / 8, 0, 0));
   }
 
   // Test constructing an image from an ARGB buffer with horizontal cropping.
   void ConstructARGBCropHorizontal() {
-    T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
-    EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight,
-                           &frame1));
+    std::unique_ptr<T> frame1 = ConvertRgb(ms.get(), cricket::FOURCC_ARGB,
+                                           kWidth, kHeight);
+    ASSERT_TRUE(frame1);
+    T frame2;
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight,
                           kWidth * 3 / 4, kHeight, webrtc::kVideoRotation_0,
                           &frame2));
-    EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, kWidth / 8, 0, 2));
+    EXPECT_TRUE(IsEqualWithCrop(frame2, *frame1, kWidth / 8, 0, 2));
   }
 
   // Test constructing an image from an I420 buffer, cropping top and bottom.
   void ConstructI420CropVertical() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_I420, kWidth, kHeight,
                           kWidth, kHeight * 3 / 4, webrtc::kVideoRotation_0,
                           &frame2));
     EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, 0, kHeight / 8, 0));
@@ skipping 236 matching lines @@
   void ConstructCopyIsRef() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame2.Init(frame1));
     }
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
     EXPECT_EQ(frame1.video_frame_buffer(), frame2.video_frame_buffer());
   }
 
-  // Test creating an empty image and initing it to black.
-  void ConstructBlack() {
-    T frame;
-    for (int i = 0; i < repeat_; ++i) {
-      EXPECT_TRUE(frame.InitToBlack(kWidth, kHeight, 0));
-    }
-    EXPECT_TRUE(IsSize(frame, kWidth, kHeight));
-    EXPECT_TRUE(IsBlack(frame));
-  }
-
   // Test constructing an image from a YUY2 buffer with a range of sizes.
   // Only tests that conversion does not crash or corrupt heap.
   void ConstructYuy2AllSizes() {
     T frame1, frame2;
     for (int height = kMinHeightAll; height <= kMaxHeightAll; ++height) {
       for (int width = kMinWidthAll; width <= kMaxWidthAll; ++width) {
         std::unique_ptr<rtc::MemoryStream> ms(
             CreateYuv422Sample(cricket::FOURCC_YUY2, width, height));
         ASSERT_TRUE(ms.get() != NULL);
         EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, width, height,
                                   &frame1));
         EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2,
                               width, height, &frame2));
         EXPECT_TRUE(IsEqual(frame1, frame2, 0));
       }
     }
   }
 
   // Test constructing an image from a ARGB buffer with a range of sizes.
   // Only tests that conversion does not crash or corrupt heap.
   void ConstructARGBAllSizes() {
-    T frame1, frame2;
     for (int height = kMinHeightAll; height <= kMaxHeightAll; ++height) {
       for (int width = kMinWidthAll; width <= kMaxWidthAll; ++width) {
         std::unique_ptr<rtc::MemoryStream> ms(
             CreateRgbSample(cricket::FOURCC_ARGB, width, height));
         ASSERT_TRUE(ms.get() != NULL);
-        EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, width, height,
-                               &frame1));
+        std::unique_ptr<T> frame1 = ConvertRgb(ms.get(), cricket::FOURCC_ARGB,
+                                               width, height);
+        ASSERT_TRUE(frame1);
+        T frame2;
         EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB,
                               width, height, &frame2));
-        EXPECT_TRUE(IsEqual(frame1, frame2, 64));
+        EXPECT_TRUE(IsEqual(*frame1, frame2, 64));
       }
     }
     // Test a practical window size for screencasting usecase.
     const int kOddWidth = 1228;
     const int kOddHeight = 260;
     for (int j = 0; j < 2; ++j) {
       for (int i = 0; i < 2; ++i) {
         std::unique_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ARGB, kOddWidth + i, kOddHeight + j));
         ASSERT_TRUE(ms.get() != NULL);
-        EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB,
-                               kOddWidth + i, kOddHeight + j,
-                               &frame1));
+        std::unique_ptr<T> frame1 = ConvertRgb(ms.get(), cricket::FOURCC_ARGB,
+                                               kOddWidth + i, kOddHeight + j);
+        ASSERT_TRUE(frame1);
+        T frame2;
         EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB,
                               kOddWidth + i, kOddHeight + j, &frame2));
-        EXPECT_TRUE(IsEqual(frame1, frame2, 64));
+        EXPECT_TRUE(IsEqual(*frame1, frame2, 64));
       }
     }
   }
 
   //////////////////////
   // Conversion tests //
   //////////////////////
 
   enum ToFrom { TO, FROM };
 
@@ skipping 29 matching lines @@
       out += (kHeight - 1) * stride;  // Point to last row.
       stride = -stride;
     }
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
 
     for (int i = 0; i < repeat_to; ++i) {
       EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(fourcc,
                                                     out,
                                                     out_size, stride));
     }
-    EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 0));
+    frame2.InitToEmptyBuffer(kWidth, kHeight, 0);
     for (int i = 0; i < repeat_from; ++i) {
       EXPECT_EQ(0, RGBToI420(out, stride,
                              frame2.video_frame_buffer()->MutableDataY(),
                              frame2.video_frame_buffer()->StrideY(),
                              frame2.video_frame_buffer()->MutableDataU(),
                              frame2.video_frame_buffer()->StrideU(),
                              frame2.video_frame_buffer()->MutableDataV(),
                              frame2.video_frame_buffer()->StrideV(),
                              kWidth, kHeight));
     }
@@ skipping 334 matching lines @@
     std::unique_ptr<const cricket::VideoFrame> target;
     ASSERT_TRUE(LoadFrameNoRepeat(source.get()));
     target.reset(source->Copy());
     EXPECT_TRUE(IsEqual(*source, *target, 0));
     const T* const_source = source.get();
     EXPECT_EQ(const_source->video_frame_buffer(), target->video_frame_buffer());
   }
 
   void StretchToFrame() {
     // Create the source frame as a black frame.
-    T source;
-    EXPECT_TRUE(source.InitToBlack(kWidth * 2, kHeight * 2, 0));
+    rtc::scoped_refptr<webrtc::I420Buffer> buffer(
+        new rtc::RefCountedObject<webrtc::I420Buffer>(kWidth * 2, kHeight * 2));
+
+    buffer->SetToBlack();
+    T source(buffer, 0, webrtc::kVideoRotation_0);
+
     EXPECT_TRUE(IsSize(source, kWidth * 2, kHeight * 2));
 
     // Create the target frame by loading from a file.
     T target1;
     ASSERT_TRUE(LoadFrameNoRepeat(&target1));
     EXPECT_FALSE(IsBlack(target1));
 
     // Stretch and check if the stretched target is black.
     source.StretchToFrame(&target1, true, false);
     EXPECT_TRUE(IsBlack(target1));
 
     // Crop and stretch and check if the stretched target is black.
     T target2;
     ASSERT_TRUE(LoadFrameNoRepeat(&target2));
     source.StretchToFrame(&target2, true, true);
     EXPECT_TRUE(IsBlack(target2));
     EXPECT_EQ(source.GetTimeStamp(), target2.GetTimeStamp());
   }
 
   int repeat_;
 };
 
 #endif  // WEBRTC_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_