Replace the remaining scoped_ptr with unique_ptr in webrtc/modules/

webrtc/modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc

 /*
  *  Copyright (c) 2015 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 <vector>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 namespace {
 void VerifyHeader(const RTPVideoHeaderVP9& expected,
@@ skipping 48 matching lines @@
   EXPECT_EQ(payload_length, parsed.payload_length);
   EXPECT_THAT(std::vector<uint8_t>(parsed.payload,
                                    parsed.payload + parsed.payload_length),
               ::testing::ElementsAreArray(payload, payload_length));
 }
 
 void ParseAndCheckPacket(const uint8_t* packet,
                          const RTPVideoHeaderVP9& expected,
                          size_t expected_hdr_length,
                          size_t expected_length) {
-  rtc::scoped_ptr<RtpDepacketizer> depacketizer(new RtpDepacketizerVp9());
+  std::unique_ptr<RtpDepacketizer> depacketizer(new RtpDepacketizerVp9());
   RtpDepacketizer::ParsedPayload parsed;
   ASSERT_TRUE(depacketizer->Parse(&parsed, packet, expected_length));
   EXPECT_EQ(kRtpVideoVp9, parsed.type.Video.codec);
   VerifyHeader(expected, parsed.type.Video.codecHeader.VP9);
   const size_t kExpectedPayloadLength = expected_length - expected_hdr_length;
   VerifyPayload(parsed, packet + expected_hdr_length, kExpectedPayloadLength);
 }
 }  // namespace
 
 // Payload descriptor for flexible mode
@@ skipping 30 matching lines @@
 //        | ..            |
 //        +-+-+-+-+-+-+-+-+
 
 class RtpPacketizerVp9Test : public ::testing::Test {
  protected:
   RtpPacketizerVp9Test() {}
   virtual void SetUp() {
     expected_.InitRTPVideoHeaderVP9();
   }
 
-  rtc::scoped_ptr<uint8_t[]> packet_;
-  rtc::scoped_ptr<uint8_t[]> payload_;
+  std::unique_ptr<uint8_t[]> packet_;
+  std::unique_ptr<uint8_t[]> payload_;
   size_t payload_size_;
   size_t payload_pos_;
   RTPVideoHeaderVP9 expected_;
-  rtc::scoped_ptr<RtpPacketizerVp9> packetizer_;
+  std::unique_ptr<RtpPacketizerVp9> packetizer_;
 
   void Init(size_t payload_size, size_t packet_size) {
     payload_.reset(new uint8_t[payload_size]);
     memset(payload_.get(), 7, payload_size);
     payload_size_ = payload_size;
     payload_pos_ = 0;
     packetizer_.reset(new RtpPacketizerVp9(expected_, packet_size));
     packetizer_->SetPayloadData(payload_.get(), payload_size_, NULL);
 
     const int kMaxPayloadDescriptorLength = 100;
@@ skipping 316 matching lines @@
 class RtpDepacketizerVp9Test : public ::testing::Test {
  protected:
   RtpDepacketizerVp9Test()
       : depacketizer_(new RtpDepacketizerVp9()) {}
 
   virtual void SetUp() {
     expected_.InitRTPVideoHeaderVP9();
   }
 
   RTPVideoHeaderVP9 expected_;
-  rtc::scoped_ptr<RtpDepacketizer> depacketizer_;
+  std::unique_ptr<RtpDepacketizer> depacketizer_;
 };
 
 TEST_F(RtpDepacketizerVp9Test, ParseBasicHeader) {
   const uint8_t kHeaderLength = 1;
   uint8_t packet[4] = {0};
   packet[0] = 0x0C;  // I:0 P:0 L:0 F:0 B:1 E:1 V:0 R:0
   expected_.beginning_of_frame = true;
   expected_.end_of_frame = true;
   ParseAndCheckPacket(packet, expected_, kHeaderLength, sizeof(packet));
 }
@@ skipping 198 matching lines @@
 }
 
 TEST_F(RtpDepacketizerVp9Test, ParseFailsForTooShortBufferToFitPayload) {
   const uint8_t kHeaderLength = 1;
   uint8_t packet[kHeaderLength] = {0};
   RtpDepacketizer::ParsedPayload parsed;
   EXPECT_FALSE(depacketizer_->Parse(&parsed, packet, sizeof(packet)));
 }
 
 }  // namespace webrtc