Replace scoped_ptr with unique_ptr in webrtc/modules/video_coding/

webrtc/modules/video_coding/jitter_buffer_unittest.cc

 /*
  *  Copyright (c) 2011 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 <string.h>
 
 #include <list>
+#include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/modules/video_coding/frame_buffer.h"
 #include "webrtc/modules/video_coding/jitter_buffer.h"
 #include "webrtc/modules/video_coding/media_opt_util.h"
 #include "webrtc/modules/video_coding/packet.h"
 #include "webrtc/modules/video_coding/test/stream_generator.h"
 #include "webrtc/modules/video_coding/test/test_util.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/metrics.h"
@@ skipping 159 matching lines @@
   EXPECT_EQ(1, packet_.codecSpecificHeader.codecHeader.VP9.pid_diff[0]);
   EXPECT_EQ(2, packet_.codecSpecificHeader.codecHeader.VP9.pid_diff[1]);
 }
 
 class TestBasicJitterBuffer : public ::testing::Test {
  protected:
   virtual void SetUp() {
     clock_.reset(new SimulatedClock(0));
     jitter_buffer_.reset(new VCMJitterBuffer(
         clock_.get(),
-        rtc::scoped_ptr<EventWrapper>(event_factory_.CreateEvent())));
+        std::unique_ptr<EventWrapper>(event_factory_.CreateEvent())));
     jitter_buffer_->Start();
     seq_num_ = 1234;
     timestamp_ = 0;
     size_ = 1400;
     // Data vector -  0, 0, 0x80, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0x80, 3....
     data_[0] = 0;
     data_[1] = 0;
     data_[2] = 0x80;
     int count = 3;
     for (unsigned int i = 3; i < sizeof(data_) - 3; ++i) {
@@ skipping 62 matching lines @@
           count = 3;
         }
       }
     }
   }
 
   uint16_t seq_num_;
   uint32_t timestamp_;
   int size_;
   uint8_t data_[1500];
-  rtc::scoped_ptr<VCMPacket> packet_;
-  rtc::scoped_ptr<SimulatedClock> clock_;
+  std::unique_ptr<VCMPacket> packet_;
+  std::unique_ptr<SimulatedClock> clock_;
   NullEventFactory event_factory_;
-  rtc::scoped_ptr<VCMJitterBuffer> jitter_buffer_;
+  std::unique_ptr<VCMJitterBuffer> jitter_buffer_;
 };
 
 class TestRunningJitterBuffer : public ::testing::Test {
  protected:
   enum { kDataBufferSize = 10 };
 
   virtual void SetUp() {
     clock_.reset(new SimulatedClock(0));
     max_nack_list_size_ = 150;
     oldest_packet_to_nack_ = 250;
     jitter_buffer_ = new VCMJitterBuffer(
         clock_.get(),
-        rtc::scoped_ptr<EventWrapper>(event_factory_.CreateEvent()));
+        std::unique_ptr<EventWrapper>(event_factory_.CreateEvent()));
     stream_generator_ = new StreamGenerator(0, clock_->TimeInMilliseconds());
     jitter_buffer_->Start();
     jitter_buffer_->SetNackSettings(max_nack_list_size_, oldest_packet_to_nack_,
                                     0);
     memset(data_buffer_, 0, kDataBufferSize);
   }
 
   virtual void TearDown() {
     jitter_buffer_->Stop();
     delete stream_generator_;
@@ skipping 70 matching lines @@
     if (!found_frame)
       return false;
     VCMEncodedFrame* frame = jitter_buffer_->ExtractAndSetDecode(timestamp);
     bool ret = (frame != NULL);
     jitter_buffer_->ReleaseFrame(frame);
     return ret;
   }
 
   VCMJitterBuffer* jitter_buffer_;
   StreamGenerator* stream_generator_;
-  rtc::scoped_ptr<SimulatedClock> clock_;
+  std::unique_ptr<SimulatedClock> clock_;
   NullEventFactory event_factory_;
   size_t max_nack_list_size_;
   int oldest_packet_to_nack_;
   uint8_t data_buffer_[kDataBufferSize];
 };
 
 class TestJitterBufferNack : public TestRunningJitterBuffer {
  protected:
   virtual void SetUp() {
     TestRunningJitterBuffer::SetUp();
@@ skipping 2168 matching lines @@
 
   // Stream should be decodable from this point.
   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   InsertFrame(kVideoFrameDelta);
   EXPECT_TRUE(DecodeCompleteFrame());
   nack_list = jitter_buffer_->GetNackList(&extended);
   EXPECT_EQ(0u, nack_list.size());
 }
 
 }  // namespace webrtc