Replace scoped_ptr with unique_ptr in webrtc/modules/video_*/

webrtc/modules/video_capture/test/video_capture_unittest.cc

 /*
  *  Copyright (c) 2012 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 <stdio.h>
 
 #include <map>
+#include <memory>
 #include <sstream>
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_capture/video_capture.h"
 #include "webrtc/modules/video_capture/video_capture_factory.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/video_frame.h"
 
-using rtc::scoped_ptr;
+using std::unique_ptr;

[stefan-webrtc, 2016/02/25 14:57:33]

I guess you can remove this if you're anyway writing std::unique_ptr below.

[kwiberg-webrtc, 2016/02/27 13:14:47]

Done.

 using webrtc::CriticalSectionWrapper;
 using webrtc::CriticalSectionScoped;
 using webrtc::SleepMs;
 using webrtc::TickTime;
 using webrtc::VideoCaptureAlarm;
 using webrtc::VideoCaptureCapability;
 using webrtc::VideoCaptureDataCallback;
 using webrtc::VideoCaptureFactory;
 using webrtc::VideoCaptureFeedBack;
 using webrtc::VideoCaptureModule;
@@ skipping 137 matching lines @@
     CriticalSectionScoped cs(capture_cs_.get());
     return CompareFrames(last_frame_, frame);
   }
 
   void SetExpectedCaptureRotation(webrtc::VideoRotation rotation) {
     CriticalSectionScoped cs(capture_cs_.get());
     rotate_frame_ = rotation;
   }
 
  private:
-  scoped_ptr<CriticalSectionWrapper> capture_cs_;
+  std::unique_ptr<CriticalSectionWrapper> capture_cs_;
   VideoCaptureCapability capability_;
   int capture_delay_;
   int64_t last_render_time_ms_;
   int incoming_frames_;
   int timing_warnings_;
   webrtc::VideoFrame last_frame_;
   webrtc::VideoRotation rotate_frame_;
 };
 
 class TestVideoCaptureFeedBack : public VideoCaptureFeedBack {
@@ skipping 19 matching lines @@
     CriticalSectionScoped cs(capture_cs_.get());
     return frame_rate_;
 
   }
   VideoCaptureAlarm alarm() {
     CriticalSectionScoped cs(capture_cs_.get());
     return alarm_;
   }
 
  private:
-  scoped_ptr<CriticalSectionWrapper> capture_cs_;
+  std::unique_ptr<CriticalSectionWrapper> capture_cs_;
   unsigned int frame_rate_;
   VideoCaptureAlarm alarm_;
 };
 
 class VideoCaptureTest : public testing::Test {
  public:
   VideoCaptureTest() : number_of_devices_(0) {}
 
   void SetUp() {
     device_info_.reset(VideoCaptureFactory::CreateDeviceInfo(0));
@@ skipping 26 matching lines @@
                     VideoCaptureCapability capability) {
     ASSERT_EQ(0, capture_module->StartCapture(capability));
     EXPECT_TRUE(capture_module->CaptureStarted());
 
     VideoCaptureCapability resulting_capability;
     EXPECT_EQ(0, capture_module->CaptureSettings(resulting_capability));
     EXPECT_EQ(capability.width, resulting_capability.width);
     EXPECT_EQ(capability.height, resulting_capability.height);
   }
 
-  scoped_ptr<VideoCaptureModule::DeviceInfo> device_info_;
+  std::unique_ptr<VideoCaptureModule::DeviceInfo> device_info_;
   unsigned int number_of_devices_;
 };
 
 #ifdef WEBRTC_MAC
 // Currently fails on Mac 64-bit, see
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=5406
 #define MAYBE_CreateDelete DISABLED_CreateDelete
 #else
 #define MAYBE_CreateDelete CreateDelete
 #endif
@@ skipping 149 matching lines @@
   EXPECT_EQ(0, module2->StopCapture());
   EXPECT_EQ(0, module1->StopCapture());
 }
 
 // Test class for testing external capture and capture feedback information
 // such as frame rate and picture alarm.
 class VideoCaptureExternalTest : public testing::Test {
  public:
   void SetUp() {
     capture_module_ = VideoCaptureFactory::Create(0, capture_input_interface_);
-    process_module_ = webrtc::ProcessThread::Create("ProcessThread");
+    process_module_ =
+        rtc::ScopedToUnique(webrtc::ProcessThread::Create("ProcessThread"));
     process_module_->Start();
     process_module_->RegisterModule(capture_module_);
 
     VideoCaptureCapability capability;
     capability.width = kTestWidth;
     capability.height = kTestHeight;
     capability.rawType = webrtc::kVideoYV12;
     capability.maxFPS = kTestFramerate;
     capture_callback_.SetExpectedCapability(capability);
 
@@ skipping 11 matching lines @@
     capture_module_->EnableFrameRateCallback(true);
     capture_module_->EnableNoPictureAlarm(true);
   }
 
   void TearDown() {
     process_module_->Stop();
   }
 
   webrtc::VideoCaptureExternal* capture_input_interface_;
   rtc::scoped_refptr<VideoCaptureModule> capture_module_;
-  rtc::scoped_ptr<webrtc::ProcessThread> process_module_;
+  std::unique_ptr<webrtc::ProcessThread> process_module_;
   webrtc::VideoFrame test_frame_;
   TestVideoCaptureCallback capture_callback_;
   TestVideoCaptureFeedBack capture_feedback_;
 };
 
 // Test input of external video frames.
 TEST_F(VideoCaptureExternalTest, TestExternalCapture) {
   size_t length = webrtc::CalcBufferSize(webrtc::kI420,
                                          test_frame_.width(),
                                          test_frame_.height());
-  scoped_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
+  std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
   webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
       length, capture_callback_.capability(), 0));
   EXPECT_TRUE(capture_callback_.CompareLastFrame(test_frame_));
 }
 
 // Test frame rate and no picture alarm.
 // Flaky on Win32, see webrtc:3270.
 #if defined(WEBRTC_WIN)
 #define MAYBE_FrameRate DISABLED_FrameRate
 #else
 #define MAYBE_FrameRate FrameRate
 #endif
 TEST_F(VideoCaptureExternalTest, MAYBE_FrameRate) {
   int64_t testTime = 3;
   TickTime startTime = TickTime::Now();
 
   while ((TickTime::Now() - startTime).Milliseconds() < testTime * 1000) {
      size_t length = webrtc::CalcBufferSize(webrtc::kI420,
                                             test_frame_.width(),
                                             test_frame_.height());
-     scoped_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
+     std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
      webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
      EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
        length, capture_callback_.capability(), 0));
     SleepMs(100);
   }
   EXPECT_TRUE(capture_feedback_.frame_rate() >= 8 &&
               capture_feedback_.frame_rate() <= 10);
   SleepMs(500);
   EXPECT_EQ(webrtc::Raised, capture_feedback_.alarm());
 
   startTime = TickTime::Now();
   while ((TickTime::Now() - startTime).Milliseconds() < testTime * 1000) {
     size_t length = webrtc::CalcBufferSize(webrtc::kI420,
                                            test_frame_.width(),
                                            test_frame_.height());
-    scoped_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
+    std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
     webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
     EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
       length, capture_callback_.capability(), 0));
     SleepMs(1000 / 30);
   }
   EXPECT_EQ(webrtc::Cleared, capture_feedback_.alarm());
   // Frame rate might be less than 33 since we have paused providing
   // frames for a while.
   EXPECT_TRUE(capture_feedback_.frame_rate() >= 25 &&
               capture_feedback_.frame_rate() <= 33);
 }
 
 TEST_F(VideoCaptureExternalTest, Rotation) {
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_0));
   size_t length = webrtc::CalcBufferSize(webrtc::kI420,
                                          test_frame_.width(),
                                          test_frame_.height());
-  scoped_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
+  std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
   webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_90));
   capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_90);
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_180));
   capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_180);
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_270));
   capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_270);
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
 }