Replace scoped_ptr with unique_ptr in webrtc/pc/

webrtc/pc/planarfunctions_unittest.cc

 /*
  *  Copyright 2014 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.
  */
 
+#include <memory>
 #include <string>
 
 #include "libyuv/convert.h"
 #include "libyuv/convert_from.h"
 #include "libyuv/convert_from_argb.h"
 #include "libyuv/mjpeg_decoder.h"
 #include "libyuv/planar_functions.h"
 #include "webrtc/base/flags.h"
 #include "webrtc/base/gunit.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/media/base/testutils.h"
 #include "webrtc/media/base/videocommon.h"
 
 // Undefine macros for the windows build.
 #undef max
 #undef min
 
 using cricket::DumpPlanarYuvTestImage;
 
 DEFINE_bool(planarfunctions_dump, false,
@@ skipping 431 matching lines @@
     const testing::TestInfo* const test_info =
         testing::UnitTest::GetInstance()->current_test_info();
     std::string test_name(test_info->name());
     return test_name;
   }
 
   bool dump_;
   int repeat_;
 
   // Y, U, V and R, G, B channels of testing colors.
-  rtc::scoped_ptr<uint8_t[]> testing_color_y_;
-  rtc::scoped_ptr<uint8_t[]> testing_color_u_;
-  rtc::scoped_ptr<uint8_t[]> testing_color_v_;
-  rtc::scoped_ptr<uint8_t[]> testing_color_r_;
-  rtc::scoped_ptr<uint8_t[]> testing_color_g_;
-  rtc::scoped_ptr<uint8_t[]> testing_color_b_;
+  std::unique_ptr<uint8_t[]> testing_color_y_;
+  std::unique_ptr<uint8_t[]> testing_color_u_;
+  std::unique_ptr<uint8_t[]> testing_color_v_;
+  std::unique_ptr<uint8_t[]> testing_color_r_;
+  std::unique_ptr<uint8_t[]> testing_color_g_;
+  std::unique_ptr<uint8_t[]> testing_color_b_;
 };
 
 TEST_F(PlanarFunctionsTest, I420Copy) {
   uint8_t* y_pointer = nullptr;
   uint8_t* u_pointer = nullptr;
   uint8_t* v_pointer = nullptr;
   int y_pitch = kWidth;
   int u_pitch = (kWidth + 1) >> 1;
   int v_pitch = (kWidth + 1) >> 1;
   int y_size = kHeight * kWidth;
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
   int block_size = 3;
   // Generate a fake input image.
-  rtc::scoped_ptr<uint8_t[]> yuv_input(CreateFakeYuvTestingImage(
+  std::unique_ptr<uint8_t[]> yuv_input(CreateFakeYuvTestingImage(
       kHeight, kWidth, block_size, libyuv::kJpegYuv420, y_pointer, u_pointer,
       v_pointer));
   // Allocate space for the output image.
-  rtc::scoped_ptr<uint8_t[]> yuv_output(
+  std::unique_ptr<uint8_t[]> yuv_output(
       new uint8_t[I420_SIZE(kHeight, kWidth) + kAlignment]);
   uint8_t* y_output_pointer = ALIGNP(yuv_output.get(), kAlignment);
   uint8_t* u_output_pointer = y_output_pointer + y_size;
   uint8_t* v_output_pointer = u_output_pointer + uv_size;
 
   for (int i = 0; i < repeat_; ++i) {
   libyuv::I420Copy(y_pointer, y_pitch,
                    u_pointer, u_pitch,
                    v_pointer, v_pitch,
                    y_output_pointer, y_pitch,
@@ skipping 13 matching lines @@
   uint8_t* y_pointer = nullptr;
   uint8_t* u_pointer = nullptr;
   uint8_t* v_pointer = nullptr;
   int y_pitch = kWidth;
   int u_pitch = (kWidth + 1) >> 1;
   int v_pitch = (kWidth + 1) >> 1;
   int y_size = kHeight * kWidth;
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
   int block_size = 2;
   // Generate a fake input image.
-  rtc::scoped_ptr<uint8_t[]> yuv_input(CreateFakeYuvTestingImage(
+  std::unique_ptr<uint8_t[]> yuv_input(CreateFakeYuvTestingImage(
       kHeight, kWidth, block_size, libyuv::kJpegYuv422, y_pointer, u_pointer,
       v_pointer));
   // Allocate space for the output image.
-  rtc::scoped_ptr<uint8_t[]> yuv_output(
+  std::unique_ptr<uint8_t[]> yuv_output(
       new uint8_t[I420_SIZE(kHeight, kWidth) + kAlignment]);
   uint8_t* y_output_pointer = ALIGNP(yuv_output.get(), kAlignment);
   uint8_t* u_output_pointer = y_output_pointer + y_size;
   uint8_t* v_output_pointer = u_output_pointer + uv_size;
   // Generate the expected output.
   uint8_t* y_expected_pointer = nullptr;
   uint8_t* u_expected_pointer = nullptr;
   uint8_t* v_expected_pointer = nullptr;
-  rtc::scoped_ptr<uint8_t[]> yuv_output_expected(CreateFakeYuvTestingImage(
+  std::unique_ptr<uint8_t[]> yuv_output_expected(CreateFakeYuvTestingImage(
       kHeight, kWidth, block_size, libyuv::kJpegYuv420, y_expected_pointer,
       u_expected_pointer, v_expected_pointer));
 
   for (int i = 0; i < repeat_; ++i) {
   libyuv::I422ToI420(y_pointer, y_pitch,
                      u_pointer, u_pitch,
                      v_pointer, v_pitch,
                      y_output_pointer, y_pitch,
                      u_output_pointer, u_pitch,
                      v_output_pointer, v_pitch,
@@ skipping 14 matching lines @@
   int unalignment = GetParam();
   uint8_t* m420_pointer = NULL;
   int y_pitch = kWidth;
   int m420_pitch = kWidth;
   int u_pitch = (kWidth + 1) >> 1;
   int v_pitch = (kWidth + 1) >> 1;
   int y_size = kHeight * kWidth;
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
   int block_size = 2;
   // Generate a fake input image.
-  rtc::scoped_ptr<uint8_t[]> yuv_input(
+  std::unique_ptr<uint8_t[]> yuv_input(
       CreateFakeM420TestingImage(kHeight, kWidth, block_size, m420_pointer));
   // Allocate space for the output image.
-  rtc::scoped_ptr<uint8_t[]> yuv_output(
+  std::unique_ptr<uint8_t[]> yuv_output(
       new uint8_t[I420_SIZE(kHeight, kWidth) + kAlignment + unalignment]);
   uint8_t* y_output_pointer =
       ALIGNP(yuv_output.get(), kAlignment) + unalignment;
   uint8_t* u_output_pointer = y_output_pointer + y_size;
   uint8_t* v_output_pointer = u_output_pointer + uv_size;
   // Generate the expected output.
   uint8_t* y_expected_pointer = nullptr;
   uint8_t* u_expected_pointer = nullptr;
   uint8_t* v_expected_pointer = nullptr;
-  rtc::scoped_ptr<uint8_t[]> yuv_output_expected(CreateFakeYuvTestingImage(
+  std::unique_ptr<uint8_t[]> yuv_output_expected(CreateFakeYuvTestingImage(
       kHeight, kWidth, block_size, libyuv::kJpegYuv420, y_expected_pointer,
       u_expected_pointer, v_expected_pointer));
 
   for (int i = 0; i < repeat_; ++i) {
   libyuv::M420ToI420(m420_pointer, m420_pitch,
                      y_output_pointer, y_pitch,
                      u_output_pointer, u_pitch,
                      v_output_pointer, v_pitch,
                      kWidth, kHeight);
   }
@@ skipping 12 matching lines @@
   uint8_t* y_pointer = nullptr;
   uint8_t* uv_pointer = nullptr;
   int y_pitch = kWidth;
   int uv_pitch = 2 * ((kWidth + 1) >> 1);
   int u_pitch = (kWidth + 1) >> 1;
   int v_pitch = (kWidth + 1) >> 1;
   int y_size = kHeight * kWidth;
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
   int block_size = 2;
   // Generate a fake input image.
-  rtc::scoped_ptr<uint8_t[]> yuv_input(CreateFakeNV12TestingImage(
+  std::unique_ptr<uint8_t[]> yuv_input(CreateFakeNV12TestingImage(
       kHeight, kWidth, block_size, y_pointer, uv_pointer));
   // Allocate space for the output image.
-  rtc::scoped_ptr<uint8_t[]> yuv_output(
+  std::unique_ptr<uint8_t[]> yuv_output(
       new uint8_t[I420_SIZE(kHeight, kWidth) + kAlignment + unalignment]);
   uint8_t* y_output_pointer =
       ALIGNP(yuv_output.get(), kAlignment) + unalignment;
   uint8_t* u_output_pointer = y_output_pointer + y_size;
   uint8_t* v_output_pointer = u_output_pointer + uv_size;
   // Generate the expected output.
   uint8_t* y_expected_pointer = nullptr;
   uint8_t* u_expected_pointer = nullptr;
   uint8_t* v_expected_pointer = nullptr;
-  rtc::scoped_ptr<uint8_t[]> yuv_output_expected(CreateFakeYuvTestingImage(
+  std::unique_ptr<uint8_t[]> yuv_output_expected(CreateFakeYuvTestingImage(
       kHeight, kWidth, block_size, libyuv::kJpegYuv420, y_expected_pointer,
       u_expected_pointer, v_expected_pointer));
 
   for (int i = 0; i < repeat_; ++i) {
   libyuv::NV12ToI420(y_pointer, y_pitch,
                      uv_pointer, uv_pitch,
                      y_output_pointer, y_pitch,
                      u_output_pointer, u_pitch,
                      v_output_pointer, v_pitch,
                      kWidth, kHeight);
@@ skipping 14 matching lines @@
     int unalignment = GetParam();                                             \
     uint8_t* yuv_pointer = nullptr;                                           \
     int yuv_pitch = 2 * ((kWidth + 1) & ~1);                                  \
     int y_pitch = kWidth;                                                     \
     int u_pitch = (kWidth + 1) >> 1;                                          \
     int v_pitch = (kWidth + 1) >> 1;                                          \
     int y_size = kHeight * kWidth;                                            \
     int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);                 \
     int block_size = 2;                                                       \
     /* Generate a fake input image.*/                                         \
-    rtc::scoped_ptr<uint8_t[]> yuv_input(CreateFakeInterleaveYuvTestingImage( \
+    std::unique_ptr<uint8_t[]> yuv_input(CreateFakeInterleaveYuvTestingImage( \
         kHeight, kWidth, BLOCK_SIZE, yuv_pointer, FOURCC_##SRC_NAME));        \
     /* Allocate space for the output image.*/                                 \
-    rtc::scoped_ptr<uint8_t[]> yuv_output(                                    \
+    std::unique_ptr<uint8_t[]> yuv_output(                                    \
         new uint8_t[I420_SIZE(kHeight, kWidth) + kAlignment + unalignment]);  \
     uint8_t* y_output_pointer =                                               \
         ALIGNP(yuv_output.get(), kAlignment) + unalignment;                   \
     uint8_t* u_output_pointer = y_output_pointer + y_size;                    \
     uint8_t* v_output_pointer = u_output_pointer + uv_size;                   \
     /* Generate the expected output.*/                                        \
     uint8_t* y_expected_pointer = nullptr;                                    \
     uint8_t* u_expected_pointer = nullptr;                                    \
     uint8_t* v_expected_pointer = nullptr;                                    \
-    rtc::scoped_ptr<uint8_t[]> yuv_output_expected(CreateFakeYuvTestingImage( \
+    std::unique_ptr<uint8_t[]> yuv_output_expected(CreateFakeYuvTestingImage( \
         kHeight, kWidth, block_size, libyuv::kJpegYuv420, y_expected_pointer, \
         u_expected_pointer, v_expected_pointer));                             \
     for (int i = 0; i < repeat_; ++i) {                                       \
       libyuv::SRC_NAME##ToI420(yuv_pointer, yuv_pitch, y_output_pointer,      \
                                y_pitch, u_output_pointer, u_pitch,            \
                                v_output_pointer, v_pitch, kWidth, kHeight);   \
     }                                                                         \
     /* Compare the output frame with what is expected.*/                      \
     /* Note: MSE should be set to a larger threshold if an odd block width*/  \
     /* is used, since the conversion will be lossy.*/                         \
@@ skipping 13 matching lines @@
 #define TEST_YUVTORGB(SRC_NAME, DST_NAME, JPG_TYPE, MSE, BLOCK_SIZE)           \
   TEST_F(PlanarFunctionsTest, SRC_NAME##To##DST_NAME) {                        \
     uint8_t* y_pointer = nullptr;                                              \
     uint8_t* u_pointer = nullptr;                                              \
     uint8_t* v_pointer = nullptr;                                              \
     uint8_t* argb_expected_pointer = NULL;                                     \
     int y_pitch = kWidth;                                                      \
     int u_pitch = (kWidth + 1) >> 1;                                           \
     int v_pitch = (kWidth + 1) >> 1;                                           \
     /* Generate a fake input image.*/                                          \
-    rtc::scoped_ptr<uint8_t[]> yuv_input(                                      \
+    std::unique_ptr<uint8_t[]> yuv_input(                                      \
         CreateFakeYuvTestingImage(kHeight, kWidth, BLOCK_SIZE, JPG_TYPE,       \
                                   y_pointer, u_pointer, v_pointer));           \
     /* Generate the expected output.*/                                         \
-    rtc::scoped_ptr<uint8_t[]> argb_expected(                                  \
+    std::unique_ptr<uint8_t[]> argb_expected(                                  \
         CreateFakeArgbTestingImage(kHeight, kWidth, BLOCK_SIZE,                \
                                    argb_expected_pointer, FOURCC_##DST_NAME)); \
     /* Allocate space for the output.*/                                        \
-    rtc::scoped_ptr<uint8_t[]> argb_output(                                    \
+    std::unique_ptr<uint8_t[]> argb_output(                                    \
         new uint8_t[kHeight * kWidth * 4 + kAlignment]);                       \
     uint8_t* argb_pointer = ALIGNP(argb_expected.get(), kAlignment);           \
     for (int i = 0; i < repeat_; ++i) {                                        \
       libyuv::SRC_NAME##To##DST_NAME(y_pointer, y_pitch, u_pointer, u_pitch,   \
                                      v_pointer, v_pitch, argb_pointer,         \
                                      kWidth * 4, kWidth, kHeight);             \
     }                                                                          \
     EXPECT_TRUE(IsMemoryEqual(argb_expected_pointer, argb_pointer,             \
                               kHeight* kWidth * 4, MSE));                      \
     if (dump_) {                                                               \
@@ skipping 16 matching lines @@
 
 TEST_F(PlanarFunctionsTest, I400ToARGB_Reference) {
   uint8_t* y_pointer = nullptr;
   uint8_t* u_pointer = nullptr;
   uint8_t* v_pointer = nullptr;
   int y_pitch = kWidth;
   int u_pitch = (kWidth + 1) >> 1;
   int v_pitch = (kWidth + 1) >> 1;
   int block_size = 3;
   // Generate a fake input image.
-  rtc::scoped_ptr<uint8_t[]> yuv_input(CreateFakeYuvTestingImage(
+  std::unique_ptr<uint8_t[]> yuv_input(CreateFakeYuvTestingImage(
       kHeight, kWidth, block_size, libyuv::kJpegYuv420, y_pointer, u_pointer,
       v_pointer));
   // As the comparison standard, we convert a grayscale image (by setting both
   // U and V channels to be 128) using an I420 converter.
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
 
-  rtc::scoped_ptr<uint8_t[]> uv(new uint8_t[uv_size + kAlignment]);
+  std::unique_ptr<uint8_t[]> uv(new uint8_t[uv_size + kAlignment]);
   u_pointer = v_pointer = ALIGNP(uv.get(), kAlignment);
   memset(u_pointer, 128, uv_size);
 
   // Allocate space for the output image and generate the expected output.
-  rtc::scoped_ptr<uint8_t[]> argb_expected(
+  std::unique_ptr<uint8_t[]> argb_expected(
       new uint8_t[kHeight * kWidth * 4 + kAlignment]);
-  rtc::scoped_ptr<uint8_t[]> argb_output(
+  std::unique_ptr<uint8_t[]> argb_output(
       new uint8_t[kHeight * kWidth * 4 + kAlignment]);
   uint8_t* argb_expected_pointer = ALIGNP(argb_expected.get(), kAlignment);
   uint8_t* argb_pointer = ALIGNP(argb_output.get(), kAlignment);
 
   libyuv::I420ToARGB(y_pointer, y_pitch,
                      u_pointer, u_pitch,
                      v_pointer, v_pitch,
                      argb_expected_pointer, kWidth * 4,
                      kWidth, kHeight);
   for (int i = 0; i < repeat_; ++i) {
@@ skipping 12 matching lines @@
   // Get the unalignment offset
   int unalignment = GetParam();
   uint8_t* y_pointer = nullptr;
   uint8_t* u_pointer = nullptr;
   uint8_t* v_pointer = nullptr;
   int y_pitch = kWidth;
   int u_pitch = (kWidth + 1) >> 1;
   int v_pitch = (kWidth + 1) >> 1;
   int block_size = 3;
   // Generate a fake input image.
-  rtc::scoped_ptr<uint8_t[]> yuv_input(CreateFakeYuvTestingImage(
+  std::unique_ptr<uint8_t[]> yuv_input(CreateFakeYuvTestingImage(
       kHeight, kWidth, block_size, libyuv::kJpegYuv420, y_pointer, u_pointer,
       v_pointer));
   // As the comparison standard, we convert a grayscale image (by setting both
   // U and V channels to be 128) using an I420 converter.
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
 
   // 1 byte extra if in the unaligned mode.
-  rtc::scoped_ptr<uint8_t[]> uv(new uint8_t[uv_size * 2 + kAlignment]);
+  std::unique_ptr<uint8_t[]> uv(new uint8_t[uv_size * 2 + kAlignment]);
   u_pointer = ALIGNP(uv.get(), kAlignment);
   v_pointer = u_pointer + uv_size;
   memset(u_pointer, 128, uv_size);
   memset(v_pointer, 128, uv_size);
 
   // Allocate space for the output image and generate the expected output.
-  rtc::scoped_ptr<uint8_t[]> argb_expected(
+  std::unique_ptr<uint8_t[]> argb_expected(
       new uint8_t[kHeight * kWidth * 4 + kAlignment]);
   // 1 byte extra if in the misalinged mode.
-  rtc::scoped_ptr<uint8_t[]> argb_output(
+  std::unique_ptr<uint8_t[]> argb_output(
       new uint8_t[kHeight * kWidth * 4 + kAlignment + unalignment]);
   uint8_t* argb_expected_pointer = ALIGNP(argb_expected.get(), kAlignment);
   uint8_t* argb_pointer = ALIGNP(argb_output.get(), kAlignment) + unalignment;
 
   libyuv::I420ToARGB(y_pointer, y_pitch,
                      u_pointer, u_pitch,
                      v_pointer, v_pitch,
                      argb_expected_pointer, kWidth * 4,
                      kWidth, kHeight);
   for (int i = 0; i < repeat_; ++i) {
@@ skipping 10 matching lines @@
 }
 
 TEST_P(PlanarFunctionsTest, ARGBToI400) {
   // Get the unalignment offset
   int unalignment = GetParam();
   // Create a fake ARGB input image.
   uint8_t* y_pointer = NULL, * u_pointer = NULL, * v_pointer = NULL;
   uint8_t* argb_pointer = NULL;
   int block_size = 3;
   // Generate a fake input image.
-  rtc::scoped_ptr<uint8_t[]> argb_input(CreateFakeArgbTestingImage(
+  std::unique_ptr<uint8_t[]> argb_input(CreateFakeArgbTestingImage(
       kHeight, kWidth, block_size, argb_pointer, FOURCC_ARGB));
   // Generate the expected output. Only Y channel is used
-  rtc::scoped_ptr<uint8_t[]> yuv_expected(CreateFakeYuvTestingImage(
+  std::unique_ptr<uint8_t[]> yuv_expected(CreateFakeYuvTestingImage(
       kHeight, kWidth, block_size, libyuv::kJpegYuv420, y_pointer, u_pointer,
       v_pointer));
   // Allocate space for the Y output.
-  rtc::scoped_ptr<uint8_t[]> y_output(
+  std::unique_ptr<uint8_t[]> y_output(
       new uint8_t[kHeight * kWidth + kAlignment + unalignment]);
   uint8_t* y_output_pointer = ALIGNP(y_output.get(), kAlignment) + unalignment;
 
   for (int i = 0; i < repeat_; ++i) {
     libyuv::ARGBToI400(argb_pointer, kWidth * 4, y_output_pointer, kWidth,
                        kWidth, kHeight);
   }
   // Check if the output matches the input Y channel.
   // Note: an empirical MSE tolerance 2.0 is used here for the probable
   // error from float-to-uint8_t type conversion.
   EXPECT_TRUE(IsMemoryEqual(y_output_pointer, y_pointer,
                             kHeight * kWidth, 2.));
   if (dump_) { DumpArgbImage(argb_pointer, kWidth, kHeight); }
 }
 
 // A common macro for testing converting RAW, BG24, BGRA, and ABGR
 // to ARGB.
 #define TEST_ARGB(SRC_NAME, FC_ID, BPP, BLOCK_SIZE)                            \
   TEST_P(PlanarFunctionsTest, SRC_NAME##ToARGB) {                              \
     int unalignment = GetParam(); /* Get the unalignment offset.*/             \
-    uint8_t* argb_expected_pointer = NULL, * src_pointer = NULL;               \
+    uint8_t *argb_expected_pointer = NULL, *src_pointer = NULL;                \
     /* Generate a fake input image.*/                                          \
-    rtc::scoped_ptr<uint8_t[]> src_input(CreateFakeArgbTestingImage(           \
+    std::unique_ptr<uint8_t[]> src_input(CreateFakeArgbTestingImage(           \
         kHeight, kWidth, BLOCK_SIZE, src_pointer, FOURCC_##FC_ID));            \
     /* Generate the expected output.*/                                         \
-    rtc::scoped_ptr<uint8_t[]> argb_expected(CreateFakeArgbTestingImage(       \
+    std::unique_ptr<uint8_t[]> argb_expected(CreateFakeArgbTestingImage(       \
         kHeight, kWidth, BLOCK_SIZE, argb_expected_pointer, FOURCC_ARGB));     \
     /* Allocate space for the output; 1 byte extra if in the unaligned mode.*/ \
-    rtc::scoped_ptr<uint8_t[]> argb_output(                                    \
+    std::unique_ptr<uint8_t[]> argb_output(                                    \
         new uint8_t[kHeight * kWidth * 4 + kAlignment + unalignment]);         \
     uint8_t* argb_pointer =                                                    \
         ALIGNP(argb_output.get(), kAlignment) + unalignment;                   \
     for (int i = 0; i < repeat_; ++i) {                                        \
       libyuv::SRC_NAME##ToARGB(src_pointer, kWidth*(BPP), argb_pointer,        \
                                kWidth * 4, kWidth, kHeight);                   \
     }                                                                          \
     /* Compare the result; expect identical.*/                                 \
     EXPECT_TRUE(IsMemoryEqual(argb_expected_pointer, argb_pointer,             \
                               kHeight* kWidth * 4, 1.e-6));                    \
@@ skipping 10 matching lines @@
 // Parameter Test: The parameter is the unalignment offset.
 // Aligned data for testing assembly versions.
 INSTANTIATE_TEST_CASE_P(PlanarFunctionsAligned, PlanarFunctionsTest,
     ::testing::Values(0));
 
 // Purposely unalign the output argb pointer to test slow path (C version).
 INSTANTIATE_TEST_CASE_P(PlanarFunctionsMisaligned, PlanarFunctionsTest,
     ::testing::Values(1));
 
 }  // namespace cricket