Replace scoped_ptr with unique_ptr in webrtc/pc/

webrtc/pc/yuvscaler_unittest.cc

 /*
  *  Copyright 2010 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 <sstream>
 
 #include "libyuv/cpu_id.h"
 #include "libyuv/scale.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/flags.h"
 #include "webrtc/base/gunit.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/media/base/testutils.h"
 
 #if defined(_MSC_VER)
 #define ALIGN16(var) __declspec(align(16)) var
 #else
 #define ALIGN16(var) var __attribute__((aligned(16)))
 #endif
 
 using cricket::LoadPlanarYuvTestImage;
 using cricket::DumpPlanarYuvTestImage;
-using rtc::scoped_ptr;
 
 DEFINE_bool(yuvscaler_dump, false,
     "whether to write out scaled images for inspection");
 DEFINE_int(yuvscaler_repeat, 1,
     "how many times to perform each scaling operation (for perf testing)");
 
 static const int kAlignment = 16;
 
 // TEST_UNCACHED flushes cache to test real memory performance.
 // TEST_RSTSC uses cpu cycles for more accurate benchmark of the scale function.
@@ skipping 37 matching lines @@
 
   // Scale an image and compare against a Lanczos-filtered test image.
   // Lanczos is considered to be the "ideal" image resampling method, so we try
   // to get as close to that as possible, while being as fast as possible.
   bool TestScale(int iw, int ih, int ow, int oh, int offset, bool usefile,
                  bool optimize, int cpuflags, bool interpolate,
                  int memoffset, double* error) {
     *error = 0.;
     size_t isize = I420_SIZE(iw, ih);
     size_t osize = I420_SIZE(ow, oh);
-    scoped_ptr<uint8_t[]> ibuffer(
+    std::unique_ptr<uint8_t[]> ibuffer(
         new uint8_t[isize + kAlignment + memoffset]());
-    scoped_ptr<uint8_t[]> obuffer(
+    std::unique_ptr<uint8_t[]> obuffer(
         new uint8_t[osize + kAlignment + memoffset]());
-    scoped_ptr<uint8_t[]> xbuffer(
+    std::unique_ptr<uint8_t[]> xbuffer(
         new uint8_t[osize + kAlignment + memoffset]());
 
     uint8_t* ibuf = ALIGNP(ibuffer.get(), kAlignment) + memoffset;
     uint8_t* obuf = ALIGNP(obuffer.get(), kAlignment) + memoffset;
     uint8_t* xbuf = ALIGNP(xbuffer.get(), kAlignment) + memoffset;
 
     if (usefile) {
       if (!LoadPlanarYuvTestImage("faces", iw, ih, ibuf) ||
           !LoadPlanarYuvTestImage("faces", ow, oh, xbuf)) {
         LOG(LS_ERROR) << "Failed to load image";
@@ skipping 83 matching lines @@
   }
   if (dump_) DumpPlanarYuvTestImage("TestCopy", obuf, ow, oh);
   EXPECT_EQ(-1, FindDiff(obuf, ibuf, sizeof(ibuf)));
 }
 
 // Tests copy from 4:3 to 16:9.
 TEST_F(YuvScalerTest, TestOffset16_10Copy) {
   const int iw = 640, ih = 360;
   const int ow = 640, oh = 480;
   const int offset = (480 - 360) / 2;
-  scoped_ptr<uint8_t[]> ibuffer(new uint8_t[I420_SIZE(iw, ih) + kAlignment]);
-  scoped_ptr<uint8_t[]> obuffer(new uint8_t[I420_SIZE(ow, oh) + kAlignment]);
+  std::unique_ptr<uint8_t[]> ibuffer(
+      new uint8_t[I420_SIZE(iw, ih) + kAlignment]);
+  std::unique_ptr<uint8_t[]> obuffer(
+      new uint8_t[I420_SIZE(ow, oh) + kAlignment]);
 
   uint8_t* ibuf = ALIGNP(ibuffer.get(), kAlignment);
   uint8_t* obuf = ALIGNP(obuffer.get(), kAlignment);
 
   // Load the frame, scale it, check it.
   ASSERT_TRUE(LoadPlanarYuvTestImage("faces", iw, ih, ibuf));
 
   // Clear to black, which is Y = 0 and U and V = 128
   memset(obuf, 0, ow * oh);
   memset(obuf + ow * oh, 128, ow * oh / 2);
@@ skipping 385 matching lines @@
 TEST_H(TestScaleDown8xHDOptInt, 1280, 720, 1280 / 8, 720 / 8, true, ALLFLAGS,
        true, 1)
 
 // Tests interpolated 1/8x scale down, using optimized algorithm.
 TEST_H(TestScaleDown9xHDOptInt, 1280, 720, 1280 / 9, 720 / 9, true, ALLFLAGS,
        true, 1)
 
 // Tests interpolated 1/8x scale down, using optimized algorithm.
 TEST_H(TestScaleDown10xHDOptInt, 1280, 720, 1280 / 10, 720 / 10, true, ALLFLAGS,
        true, 1)