Replace the remaining scoped_ptr with unique_ptr in webrtc/modules/

webrtc/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc

 /*
  *  Copyright (c) 2013 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 "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 
 namespace webrtc {
 
 using ::testing::Eq;
 using ::testing::Return;
 using ::testing::_;
@@ skipping 25 matching lines @@
     // of the created object.
     RtpUtility::Payload* returned_payload_on_heap =
         new RtpUtility::Payload(returned_payload);
     EXPECT_CALL(*mock_payload_strategy_,
                 CreatePayloadType(kTypicalPayloadName, payload_type,
                                   kTypicalFrequency, kTypicalChannels, rate))
         .WillOnce(Return(returned_payload_on_heap));
     return returned_payload_on_heap;
   }
 
-  rtc::scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
+  std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry_;
   testing::NiceMock<MockRTPPayloadStrategy>* mock_payload_strategy_;
 };
 
 TEST_F(RtpPayloadRegistryTest, RegistersAndRemembersPayloadsUntilDeregistered) {
   uint8_t payload_type = 97;
   RtpUtility::Payload* returned_payload_on_heap =
       ExpectReturnOfTypicalAudioPayload(payload_type, kTypicalRate);
 
   bool new_payload_created = false;
   EXPECT_EQ(0, rtp_payload_registry_->RegisterReceivePayload(
@@ skipping 217 matching lines @@
 
   RTPHeader header;
   header.ssrc = 1000;
   header.sequenceNumber = 100;
   header.payloadType = rtx_payload_type;
   header.headerLength = header_length;
 
   uint16_t original_sequence_number = 1234;
   uint32_t original_ssrc = 500;
 
-  rtc::scoped_ptr<const uint8_t[]> packet(GenerateRtxPacket(
+  std::unique_ptr<const uint8_t[]> packet(GenerateRtxPacket(
       header_length, payload_length, original_sequence_number));
-  rtc::scoped_ptr<uint8_t[]> restored_packet(
+  std::unique_ptr<uint8_t[]> restored_packet(
       new uint8_t[header_length + payload_length]);
   size_t length = original_length;
   bool success = rtp_payload_registry->RestoreOriginalPacket(
       restored_packet.get(), packet.get(), &length, original_ssrc, header);
   EXPECT_EQ(should_succeed, success)
       << "Test success should match should_succeed.";
   if (!success) {
     return;
   }
 
   EXPECT_EQ(original_length - kRtxHeaderSize, length)
       << "The restored packet should be exactly kRtxHeaderSize smaller.";
 
-  rtc::scoped_ptr<RtpHeaderParser> header_parser(RtpHeaderParser::Create());
+  std::unique_ptr<RtpHeaderParser> header_parser(RtpHeaderParser::Create());
   RTPHeader restored_header;
   ASSERT_TRUE(
       header_parser->Parse(restored_packet.get(), length, &restored_header));
   EXPECT_EQ(original_sequence_number, restored_header.sequenceNumber)
       << "The restored packet should have the original sequence number "
       << "in the correct location in the RTP header.";
   EXPECT_EQ(expected_payload_type, restored_header.payloadType)
       << "The restored packet should have the correct payload type.";
   EXPECT_EQ(original_ssrc, restored_header.ssrc)
       << "The restored packet should have the correct ssrc.";
@@ skipping 42 matching lines @@
   // Now that red is configured we expect to get the red payload type back on
   // recovery because of the workaround to always recover red when configured.
   TestRtxPacket(rtp_payload_registry_.get(), 105, header.payloadType, true);
 }
 
 INSTANTIATE_TEST_CASE_P(TestDynamicRange,
                         RtpPayloadRegistryGenericTest,
                         testing::Range(96, 127 + 1));
 
 }  // namespace webrtc