Replace scoped_ptr with unique_ptr in webrtc/media/

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.
  */
 
 #ifndef WEBRTC_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_
 #define WEBRTC_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_
 
 #include <algorithm>
+#include <memory>
 #include <string>
 
 #include "libyuv/convert.h"
 #include "libyuv/convert_from.h"
 #include "libyuv/planar_functions.h"
 #include "libyuv/rotate.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/pathutils.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringutils.h"
@@ skipping 49 matching lines @@
                      webrtc::kVideoRotation_0, frame);
   }
   bool LoadFrame(const std::string& filename,
                  uint32_t format,
                  int32_t width,
                  int32_t height,
                  int dw,
                  int dh,
                  webrtc::VideoRotation rotation,
                  T* frame) {
-    rtc::scoped_ptr<rtc::MemoryStream> ms(LoadSample(filename));
+    std::unique_ptr<rtc::MemoryStream> ms(LoadSample(filename));
     return LoadFrame(ms.get(), format, width, height, dw, dh, rotation, frame);
   }
   // Load a video frame from a memory stream.
   bool LoadFrame(rtc::MemoryStream* ms,
                  uint32_t format,
                  int32_t width,
                  int32_t height,
                  T* frame) {
     return LoadFrame(ms, format, width, height, width, abs(height),
                      webrtc::kVideoRotation_0, frame);
@@ skipping 40 matching lines @@
     bool ret = false;
     for (int i = 0; i < repeat_; ++i) {
       ret = frame->Init(format, width, height, dw, dh,
                         sample, sample_size, 0, rotation);
     }
     return ret;
   }
 
   rtc::MemoryStream* LoadSample(const std::string& filename) {
     rtc::Pathname path(cricket::GetTestFilePath(filename));
-    rtc::scoped_ptr<rtc::FileStream> fs(
+    std::unique_ptr<rtc::FileStream> fs(
         rtc::Filesystem::OpenFile(path, "rb"));
     if (!fs.get()) {
       LOG(LS_ERROR) << "Could not open test file path: " << path.pathname()
                     << " from current dir "
                     << rtc::Filesystem::GetCurrentDirectory().pathname();
       return NULL;
     }
 
     char buf[4096];
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream());
     rtc::StreamResult res = Flow(fs.get(), buf, sizeof(buf), ms.get());
     if (res != rtc::SR_SUCCESS) {
       LOG(LS_ERROR) << "Could not load test file path: " << path.pathname();
       return NULL;
     }
 
     return ms.release();
   }
 
   bool DumpSample(const std::string& filename, const void* buffer, int size) {
     rtc::Pathname path(filename);
-    rtc::scoped_ptr<rtc::FileStream> fs(
+    std::unique_ptr<rtc::FileStream> fs(
         rtc::Filesystem::OpenFile(path, "wb"));
     if (!fs.get()) {
       return false;
     }
 
     return (fs->Write(buffer, size, NULL, NULL) == rtc::SR_SUCCESS);
   }
 
   // Create a test image in the desired color space.
   // The image is a checkerboard pattern with 63x63 squares, which allows
   // I420 chroma artifacts to easily be seen on the square boundaries.
   // The pattern is { { green, orange }, { blue, purple } }
   // There is also a gradient within each square to ensure that the luma
   // values are handled properly.
   rtc::MemoryStream* CreateYuv422Sample(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 NULL;
     }
 
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream);
     int awidth = (width + 1) & ~1;
     int size = awidth * 2 * height;
     if (!ms->ReserveSize(size)) {
       return NULL;
     }
     for (uint32_t y = 0; y < height; ++y) {
       for (int x = 0; x < awidth; x += 2) {
         uint8_t quad[4];
         quad[y1_pos] = (x % 63 + y % 63) + 64;
         quad[y2_pos] = ((x + 1) % 63 + y % 63) + 64;
         quad[u_pos] = ((x / 63) & 1) ? 192 : 64;
         quad[v_pos] = ((y / 63) & 1) ? 192 : 64;
         ms->Write(quad, sizeof(quad), NULL, NULL);
       }
     }
     return ms.release();
   }
 
   // Create a test image for YUV 420 formats with 12 bits per pixel.
   rtc::MemoryStream* CreateYuvSample(uint32_t width,
                                      uint32_t height,
                                      uint32_t bpp) {
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream);
     if (!ms->ReserveSize(width * height * bpp / 8)) {
       return NULL;
     }
 
     for (uint32_t i = 0; i < width * height * bpp / 8; ++i) {
       uint8_t value = ((i / 63) & 1) ? 192 : 64;
       ms->Write(&value, sizeof(value), NULL, NULL);
     }
     return ms.release();
   }
 
   rtc::MemoryStream* CreateRgbSample(uint32_t fourcc,
                                      uint32_t width,
                                      uint32_t height) {
     int r_pos, g_pos, b_pos, bytes;
     if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
       return NULL;
     }
 
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream);
     if (!ms->ReserveSize(width * height * bytes)) {
       return NULL;
     }
 
     for (uint32_t y = 0; y < height; ++y) {
       for (uint32_t x = 0; x < width; ++x) {
         uint8_t rgb[4] = {255, 255, 255, 255};
         rgb[r_pos] = ((x / 63) & 1) ? 224 : 32;
         rgb[g_pos] = (x % 63 + y % 63) + 96;
@@ skipping 251 matching lines @@
   }
 
   ////////////////////////
   // Construction tests //
   ////////////////////////
 
   // Test constructing an image from a I420 buffer.
   void ConstructI420() {
     T frame;
     EXPECT_TRUE(IsNull(frame));
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420,
                           kWidth, kHeight, &frame));
 
     const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
     const uint8_t* u = y + kWidth * kHeight;
     const uint8_t* v = u + kWidth * kHeight / 4;
     EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 0, y, kWidth, u,
                         kWidth / 2, v, kWidth / 2, 0));
   }
 
   // Test constructing an image from a YV12 buffer.
   void ConstructYV12() {
     T frame;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YV12,
                           kWidth, kHeight, &frame));
 
     const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
     const uint8_t* v = y + kWidth * kHeight;
     const uint8_t* u = v + kWidth * kHeight / 4;
     EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 0, y, kWidth, u,
                         kWidth / 2, v, kWidth / 2, 0));
   }
 
   // Test constructing an image from a I422 buffer.
   void ConstructI422() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment]);
+    std::unique_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment]);
     uint8_t* y = ALIGNP(buf.get(), kAlignment);
     uint8_t* u = y + kWidth * kHeight;
     uint8_t* v = u + (kWidth / 2) * kHeight;
     EXPECT_EQ(0, libyuv::I420ToI422(frame1.GetYPlane(), frame1.GetYPitch(),
                                     frame1.GetUPlane(), frame1.GetUPitch(),
                                     frame1.GetVPlane(), frame1.GetVPitch(),
                                     y, kWidth,
                                     u, kWidth / 2,
                                     v, kWidth / 2,
                                     kWidth, kHeight));
     EXPECT_TRUE(LoadFrame(y, buf_size, cricket::FOURCC_I422,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 1));
   }
 
   // Test constructing an image from a YUY2 buffer.
   void ConstructYuy2() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment]);
+    std::unique_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment]);
     uint8_t* yuy2 = ALIGNP(buf.get(), kAlignment);
     EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(),
                                     frame1.GetUPlane(), frame1.GetUPitch(),
                                     frame1.GetVPlane(), frame1.GetVPitch(),
                                     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 YUY2 buffer with buffer unaligned.
   void ConstructYuy2Unaligned() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment + 1]);
+    std::unique_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment + 1]);
     uint8_t* yuy2 = ALIGNP(buf.get(), kAlignment) + 1;
     EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(),
                                     frame1.GetUPlane(), frame1.GetUPitch(),
                                     frame1.GetVPlane(), frame1.GetVPitch(),
                                     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;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2,
                           kWidth * 10, kHeight / 10, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
   }
 
   // Test constructing an image from a UYVY buffer.
   void ConstructUyvy() {
     T frame1, frame2;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY,
                           kWidth, kHeight, &frame2));
     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;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_M420,
                           kWidth, kHeight, &frame));
   }
 
   void ConstructNV21() {
     T frame;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_NV21,
                           kWidth, kHeight, &frame));
   }
 
   void ConstructNV12() {
     T frame;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ABGR,
                           kWidth, kHeight, &frame2));
     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;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB,
                           kWidth, kHeight, &frame2));
     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;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB,
                           kWidth * 10, kHeight / 10, &frame2));
     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;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_BGRA,
                           kWidth, kHeight, &frame2));
     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;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_24BG,
                           kWidth, kHeight, &frame2));
     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;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_RAW,
                           kWidth, kHeight, &frame2));
     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;
-    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    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));
     EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(cricket::FOURCC_RGBP,
                                                  out,
                                                  out_size, kWidth * 2));
     EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_RGBP,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 20));
   }
 
   // Test constructing an image from a ARGB1555 buffer
   void ConstructARGB1555() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    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));
     EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(cricket::FOURCC_RGBO,
                                                  out,
                                                  out_size, kWidth * 2));
     EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_RGBO,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 20));
   }
 
   // Test constructing an image from a ARGB4444 buffer
   void ConstructARGB4444() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    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));
     EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(cricket::FOURCC_R444,
                                                  out,
                                                  out_size, kWidth * 2));
     EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_R444,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 20));
   }
 
 // Macro to help test different rotations
 #define TEST_MIRROR(FOURCC, BPP)                                               \
   void Construct##FOURCC##Mirror() {                                           \
     T frame1, frame2, frame3;                                                  \
-    rtc::scoped_ptr<rtc::MemoryStream> ms(                                     \
+    std::unique_ptr<rtc::MemoryStream> ms(                                     \
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, kWidth,          \
                           -kHeight, kWidth, kHeight,                           \
                           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,                                           \
@@ skipping 10 matching lines @@
         kHeight);                                                              \
     EXPECT_TRUE(IsEqual(frame1, frame3, 0));                                   \
   }
 
   TEST_MIRROR(I420, 420)
 
 // Macro to help test different rotations
 #define TEST_ROTATE(FOURCC, BPP, ROTATE)                                       \
   void Construct##FOURCC##Rotate##ROTATE() {                                   \
     T frame1, frame2, frame3;                                                  \
-    rtc::scoped_ptr<rtc::MemoryStream> ms(                                     \
+    std::unique_ptr<rtc::MemoryStream> ms(                                     \
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, kWidth, kHeight, \
                           kWidth, kHeight, webrtc::kVideoRotation_##ROTATE,    \
                           &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,                                           \
@@ skipping 33 matching lines @@
   TEST_ROTATE(UYVY, 16, 180)
   TEST_ROTATE(UYVY, 16, 270)
   TEST_ROTATE(YUY2, 16, 0)
   TEST_ROTATE(YUY2, 16, 90)
   TEST_ROTATE(YUY2, 16, 180)
   TEST_ROTATE(YUY2, 16, 270)
 
   // Test constructing an image from a UYVY buffer rotated 90 degrees.
   void ConstructUyvyRotate90() {
     T frame2;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY, kWidth, kHeight,
                           kWidth, kHeight, webrtc::kVideoRotation_90, &frame2));
   }
 
   // Test constructing an image from a UYVY buffer rotated 180 degrees.
   void ConstructUyvyRotate180() {
     T frame2;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY, kWidth, kHeight,
                           kWidth, kHeight, webrtc::kVideoRotation_180,
                           &frame2));
   }
 
   // Test constructing an image from a UYVY buffer rotated 270 degrees.
   void ConstructUyvyRotate270() {
     T frame2;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY, kWidth, kHeight,
                           kWidth, kHeight, webrtc::kVideoRotation_270,
                           &frame2));
   }
 
   // Test constructing an image from a YUY2 buffer rotated 90 degrees.
   void ConstructYuy2Rotate90() {
     T frame2;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight,
                           kWidth, kHeight, webrtc::kVideoRotation_90, &frame2));
   }
 
   // Test constructing an image from a YUY2 buffer rotated 180 degrees.
   void ConstructYuy2Rotate180() {
     T frame2;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight,
                           kWidth, kHeight, webrtc::kVideoRotation_180,
                           &frame2));
   }
 
   // Test constructing an image from a YUY2 buffer rotated 270 degrees.
   void ConstructYuy2Rotate270() {
     T frame2;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight,
                           kWidth, kHeight, webrtc::kVideoRotation_270,
                           &frame2));
   }
 
   // Test 1 pixel edge case image I420 buffer.
   void ConstructI4201Pixel() {
     T frame;
@@ skipping 29 matching lines @@
   void ConstructARGB1Pixel() {
     T frame;
     uint8_t pixel[4] = {64, 128, 192, 255};
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_ARGB, 1, 1, 1, 1, pixel,
                              sizeof(pixel), 0,
                              webrtc::kVideoRotation_0));
     }
     // Convert back to ARGB.
     size_t out_size = 4;
-    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    std::unique_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
     uint8_t* out = ALIGNP(outbuf.get(), kAlignment);
 
     EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB,
                                                  out,
                                                  out_size,    // buffer size
                                                  out_size));  // stride
   #ifdef USE_LMI_CONVERT
     // TODO(fbarchard): Expected to fail, but not crash.
     EXPECT_FALSE(IsPlaneEqual("argb", pixel, 4, out, 4, 3, 1, 2));
   #else
@@ skipping 16 matching lines @@
                              255, 255, 255, 255,   // White.
                              255, 255, 255, 255};  // White.
 
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_ARGB, 10, 1, 10, 1, pixel,
                              sizeof(pixel), 1, 1, 0,
                              webrtc::kVideoRotation_0));
     }
     // Convert back to ARGB
     size_t out_size = 10 * 4;
-    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    std::unique_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
     uint8_t* out = ALIGNP(outbuf.get(), kAlignment);
 
     EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB,
                                                  out,
                                                  out_size,    // buffer size.
                                                  out_size));  // stride.
     EXPECT_TRUE(IsPlaneEqual("argb", pixel, out_size,
                              out, out_size,
                              out_size, 1, 2));
   }
 
   // Test constructing an image from an I420 buffer with horizontal cropping.
   void ConstructI420CropHorizontal() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_I420, kWidth, kHeight,
                           kWidth * 3 / 4, kHeight, webrtc::kVideoRotation_0,
                           &frame2));
     EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, kWidth / 8, 0, 0));
   }
 
   // Test constructing an image from a YUY2 buffer with horizontal cropping.
   void ConstructYuy2CropHorizontal() {
     T frame1, frame2;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     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;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     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));
   }
 
@@ skipping 69 matching lines @@
     EXPECT_TRUE(IsEqual(frame1, frame2, 128));
   }
 
   // Test constructing an image from an I420 MJPG buffer.
   void ValidateFrame(const char* name,
                      uint32_t fourcc,
                      int data_adjust,
                      int size_adjust,
                      bool expected_result) {
     T frame;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(LoadSample(name));
+    std::unique_ptr<rtc::MemoryStream> ms(LoadSample(name));
     ASSERT_TRUE(ms.get() != NULL);
     const uint8_t* sample =
         reinterpret_cast<const uint8_t*>(ms.get()->GetBuffer());
     size_t sample_size;
     ms->GetSize(&sample_size);
     // Optional adjust size to test invalid size.
     size_t data_size = sample_size + data_adjust;
 
     // Allocate a buffer with end page aligned.
     const int kPadToHeapSized = 16 * 1024 * 1024;
-    rtc::scoped_ptr<uint8_t[]> page_buffer(
+    std::unique_ptr<uint8_t[]> page_buffer(
         new uint8_t[((data_size + kPadToHeapSized + 4095) & ~4095)]);
     uint8_t* data_ptr = page_buffer.get();
     if (!data_ptr) {
       LOG(LS_WARNING) << "Failed to allocate memory for ValidateFrame test.";
       EXPECT_FALSE(expected_result);  // NULL is okay if failure was expected.
       return;
     }
     data_ptr += kPadToHeapSized + (-(static_cast<int>(data_size)) & 4095);
     memcpy(data_ptr, sample, std::min(data_size, sample_size));
     for (int i = 0; i < repeat_; ++i) {
@@ skipping 85 matching lines @@
       FAIL() << "Validate was expected to cause EXCEPTION_ACCESS_VIOLATION.";
     } __except(ExceptionFilter(GetExceptionCode(), GetExceptionInformation())) {
       return;  // Successfully crashed in ValidateFrame.
     }
   }
 #endif
 
   // Test constructing an image from a YUY2 buffer (and synonymous formats).
   void ConstructYuy2Aliases() {
     T frame1, frame2, frame3, frame4;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight,
                               &frame1));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUVS,
                           kWidth, kHeight, &frame3));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUYV,
                           kWidth, kHeight, &frame4));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
     EXPECT_TRUE(IsEqual(frame1, frame3, 0));
     EXPECT_TRUE(IsEqual(frame1, frame4, 0));
   }
 
   // Test constructing an image from a UYVY buffer (and synonymous formats).
   void ConstructUyvyAliases() {
     T frame1, frame2, frame3, frame4;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    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));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_2VUY,
                           kWidth, kHeight, &frame3));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_HDYC,
                           kWidth, kHeight, &frame4));
@@ skipping 34 matching lines @@
     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) {
-        rtc::scoped_ptr<rtc::MemoryStream> ms(
+        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) {
-        rtc::scoped_ptr<rtc::MemoryStream> ms(
+        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));
         EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB,
                               width, height, &frame2));
         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) {
-        rtc::scoped_ptr<rtc::MemoryStream> ms(
+        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));
         EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB,
                               kOddWidth + i, kOddHeight + j, &frame2));
         EXPECT_TRUE(IsEqual(frame1, frame2, 64));
       }
     }
   }
 
   // Tests re-initing an existing image.
   void Reset(webrtc::VideoRotation rotation, bool apply_rotation) {
     T frame1, frame2;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
     ASSERT_TRUE(ms.get() != NULL);
     size_t data_size;
     ms->GetSize(&data_size);
     EXPECT_TRUE(frame1.InitToBlack(kWidth, kHeight, 0));
     EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 0));
     EXPECT_TRUE(IsBlack(frame1));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
     EXPECT_TRUE(frame1.Reset(cricket::FOURCC_I420, kWidth, kHeight, kWidth,
                              kHeight,
@@ skipping 47 matching lines @@
                                                uint8_t* dst_v,
                                                int dst_stride_v,
                                                int width,
                                                int height)) {
     T frame1, frame2;
     int repeat_to = (to_from == TO) ? repeat_ : 1;
     int repeat_from  = (to_from == FROM) ? repeat_ : 1;
 
     int astride = kWidth * bpp + rowpad;
     size_t out_size = astride * kHeight;
-    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment + 1]);
+    std::unique_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment + 1]);
     memset(outbuf.get(), 0, out_size + kAlignment + 1);
     uint8_t* outtop = ALIGNP(outbuf.get(), kAlignment);
     uint8_t* out = outtop;
     int stride = astride;
     if (invert) {
       out += (kHeight - 1) * stride;  // Point to last row.
       stride = -stride;
     }
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
 
@@ skipping 297 matching lines @@
   }
   void ConvertFromUYVYBufferInverted() {
     ConvertToBuffer(2, 0, true, FROM, kError,
                     cricket::FOURCC_UYVY, libyuv::UYVYToI420);
   }
 
   // Test converting from I420 to I422.
   void ConvertToI422Buffer() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8_t[]> buf(new uint8_t[out_size + kAlignment]);
+    std::unique_ptr<uint8_t[]> buf(new uint8_t[out_size + kAlignment]);
     uint8_t* y = ALIGNP(buf.get(), kAlignment);
     uint8_t* u = y + kWidth * kHeight;
     uint8_t* v = u + (kWidth / 2) * kHeight;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_EQ(0, libyuv::I420ToI422(frame1.GetYPlane(), frame1.GetYPitch(),
                                       frame1.GetUPlane(), frame1.GetUPitch(),
                                       frame1.GetVPlane(), frame1.GetVPitch(),
                                       y, kWidth,
                                       u, kWidth / 2,
                                       v, kWidth / 2,
                                       kWidth, kHeight));
     }
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_I422, kWidth, kHeight, kWidth,
                             kHeight, y, out_size, 1, 1, 0,
                             webrtc::kVideoRotation_0));
     EXPECT_TRUE(IsEqual(frame1, frame2, 1));
   }
 
   ///////////////////
   // General tests //
   ///////////////////
 
   void Copy() {
-    rtc::scoped_ptr<T> source(new T);
-    rtc::scoped_ptr<cricket::VideoFrame> target;
+    std::unique_ptr<T> source(new T);
+    std::unique_ptr<cricket::VideoFrame> target;
     ASSERT_TRUE(LoadFrameNoRepeat(source.get()));
     target.reset(source->Copy());
     EXPECT_TRUE(IsEqual(*source, *target, 0));
     source.reset();
     EXPECT_TRUE(target->GetYPlane() != NULL);
   }
 
   void CopyIsRef() {
-    rtc::scoped_ptr<T> source(new T);
-    rtc::scoped_ptr<const cricket::VideoFrame> target;
+    std::unique_ptr<T> source(new T);
+    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->GetYPlane(), target->GetYPlane());
     EXPECT_EQ(const_source->GetUPlane(), target->GetUPlane());
     EXPECT_EQ(const_source->GetVPlane(), target->GetVPlane());
   }
 
   void MakeExclusive() {
-    rtc::scoped_ptr<T> source(new T);
-    rtc::scoped_ptr<cricket::VideoFrame> target;
+    std::unique_ptr<T> source(new T);
+    std::unique_ptr<cricket::VideoFrame> target;
     ASSERT_TRUE(LoadFrameNoRepeat(source.get()));
     target.reset(source->Copy());
     EXPECT_TRUE(target->MakeExclusive());
     EXPECT_TRUE(IsEqual(*source, *target, 0));
     EXPECT_NE(target->GetYPlane(), source->GetYPlane());
     EXPECT_NE(target->GetUPlane(), source->GetUPlane());
     EXPECT_NE(target->GetVPlane(), source->GetVPlane());
   }
 
   void CopyToFrame() {
     T source;
-    rtc::scoped_ptr<rtc::MemoryStream> ms(
+    std::unique_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
     ASSERT_TRUE(ms.get() != NULL);
     ASSERT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420, kWidth, kHeight,
                           &source));
 
     // Create the target frame by loading from a file.
     T target;
     ASSERT_TRUE(LoadFrameNoRepeat(&target));
     EXPECT_FALSE(IsBlack(target));
 
@@ skipping 23 matching lines @@
     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_