Replace the remaining scoped_ptr with unique_ptr in webrtc/modules/

webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc

 /*
  *  Copyright (c) 2014 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/base/scoped_ptr.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format.h"
 
 namespace webrtc {
 namespace {
 const size_t kMaxPayloadSize = 1200;
 const size_t kLengthFieldLength = 2;
 
 enum Nalu {
@@ skipping 39 matching lines @@
       &expected_payload[offset + expected_sizes[fua_index]]);
   EXPECT_THAT(
       expected_packet_payload,
       ::testing::ElementsAreArray(&packet[2], expected_sizes[fua_index]))
       << "FUA index: " << fua_index;
 }
 
 void TestFua(size_t frame_size,
              size_t max_payload_size,
              const std::vector<size_t>& expected_sizes) {
-  rtc::scoped_ptr<uint8_t[]> frame;
+  std::unique_ptr<uint8_t[]> frame;
   frame.reset(new uint8_t[frame_size]);
   frame[0] = 0x05;  // F=0, NRI=0, Type=5.
   for (size_t i = 0; i < frame_size - kNalHeaderSize; ++i) {
     frame[i + kNalHeaderSize] = i;
   }
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(1);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = frame_size;
-  rtc::scoped_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create(
+  std::unique_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create(
       kRtpVideoH264, max_payload_size, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame.get(), frame_size, &fragmentation);
 
-  rtc::scoped_ptr<uint8_t[]> packet(new uint8_t[max_payload_size]);
+  std::unique_ptr<uint8_t[]> packet(new uint8_t[max_payload_size]);
   size_t length = 0;
   bool last = false;
   size_t offset = kNalHeaderSize;
   for (size_t i = 0; i < expected_sizes.size(); ++i) {
     ASSERT_TRUE(packetizer->NextPacket(packet.get(), &length, &last));
     VerifyFua(i, frame.get(), offset, packet.get(), length, expected_sizes);
     EXPECT_EQ(i == expected_sizes.size() - 1, last) << "FUA index: " << i;
     offset += expected_sizes[i];
   }
 
@@ skipping 49 matching lines @@
               ::testing::ElementsAreArray(packet, packet_length));
 }
 }  // namespace
 
 TEST(RtpPacketizerH264Test, TestSingleNalu) {
   const uint8_t frame[2] = {0x05, 0xFF};  // F=0, NRI=0, Type=5.
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(1);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = sizeof(frame);
-  rtc::scoped_ptr<RtpPacketizer> packetizer(
+  std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation);
   uint8_t packet[kMaxPayloadSize] = {0};
   size_t length = 0;
   bool last = false;
   ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
   EXPECT_EQ(2u, length);
   EXPECT_TRUE(last);
   VerifySingleNaluPayload(
       fragmentation, 0, frame, sizeof(frame), packet, length);
   EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
 }
 
 TEST(RtpPacketizerH264Test, TestSingleNaluTwoPackets) {
   const size_t kFrameSize = kMaxPayloadSize + 100;
   uint8_t frame[kFrameSize] = {0};
   for (size_t i = 0; i < kFrameSize; ++i)
     frame[i] = i;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(2);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = kMaxPayloadSize;
   fragmentation.fragmentationOffset[1] = kMaxPayloadSize;
   fragmentation.fragmentationLength[1] = 100;
   // Set NAL headers.
   frame[fragmentation.fragmentationOffset[0]] = 0x01;
   frame[fragmentation.fragmentationOffset[1]] = 0x01;
 
-  rtc::scoped_ptr<RtpPacketizer> packetizer(
+  std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   uint8_t packet[kMaxPayloadSize] = {0};
   size_t length = 0;
   bool last = false;
   ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
   ASSERT_EQ(fragmentation.fragmentationOffset[1], length);
   VerifySingleNaluPayload(fragmentation, 0, frame, kFrameSize, packet, length);
 
@@ skipping 16 matching lines @@
     frame[i + kPayloadOffset] = i;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(3);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = 2;
   fragmentation.fragmentationOffset[1] = 2;
   fragmentation.fragmentationLength[1] = 2;
   fragmentation.fragmentationOffset[2] = 4;
   fragmentation.fragmentationLength[2] =
       kNalHeaderSize + kFrameSize - kPayloadOffset;
-  rtc::scoped_ptr<RtpPacketizer> packetizer(
+  std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   uint8_t packet[kMaxPayloadSize] = {0};
   size_t length = 0;
   bool last = false;
   ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
   size_t expected_packet_size =
       kNalHeaderSize + 3 * kLengthFieldLength + kFrameSize;
   ASSERT_EQ(expected_packet_size, length);
@@ skipping 14 matching lines @@
     frame[i + kPayloadOffset] = i;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(3);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = 2;
   fragmentation.fragmentationOffset[1] = 2;
   fragmentation.fragmentationLength[1] = 2;
   fragmentation.fragmentationOffset[2] = 4;
   fragmentation.fragmentationLength[2] =
       kNalHeaderSize + kFrameSize - kPayloadOffset;
-  rtc::scoped_ptr<RtpPacketizer> packetizer(
+  std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   uint8_t packet[kMaxPayloadSize] = {0};
   size_t length = 0;
   bool last = false;
   ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
   size_t expected_packet_size = kNalHeaderSize;
   for (size_t i = 0; i < 2; ++i) {
     expected_packet_size +=
@@ skipping 27 matching lines @@
   const size_t kFrameSize = kFuaNaluSize + 2 * kStapANaluSize;
   uint8_t frame[kFrameSize];
   size_t nalu_offset = 0;
   for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i) {
     nalu_offset = fragmentation.fragmentationOffset[i];
     frame[nalu_offset] = 0x05;  // F=0, NRI=0, Type=5.
     for (size_t j = 1; j < fragmentation.fragmentationLength[i]; ++j) {
       frame[nalu_offset + j] = i + j;
     }
   }
-  rtc::scoped_ptr<RtpPacketizer> packetizer(
+  std::unique_ptr<RtpPacketizer> packetizer(
       RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   // First expecting two FU-A packets.
   std::vector<size_t> fua_sizes;
   fua_sizes.push_back(1100);
   fua_sizes.push_back(1099);
   uint8_t packet[kMaxPayloadSize] = {0};
   size_t length = 0;
   bool last = false;
@@ skipping 68 matching lines @@
   void ExpectPacket(RtpDepacketizer::ParsedPayload* parsed_payload,
                     const uint8_t* data,
                     size_t length) {
     ASSERT_TRUE(parsed_payload != NULL);
     EXPECT_THAT(std::vector<uint8_t>(
                     parsed_payload->payload,
                     parsed_payload->payload + parsed_payload->payload_length),
                 ::testing::ElementsAreArray(data, length));
   }
 
-  rtc::scoped_ptr<RtpDepacketizer> depacketizer_;
+  std::unique_ptr<RtpDepacketizer> depacketizer_;
 };
 
 TEST_F(RtpDepacketizerH264Test, TestSingleNalu) {
   uint8_t packet[2] = {0x05, 0xFF};  // F=0, NRI=0, Type=5 (IDR).
   RtpDepacketizer::ParsedPayload payload;
 
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
@@ skipping 155 matching lines @@
   EXPECT_FALSE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload)));
 }
 
 TEST_F(RtpDepacketizerH264Test, TestShortSpsPacket) {
   const uint8_t kPayload[] = {0x27, 0x80, 0x00};
   RtpDepacketizer::ParsedPayload payload;
   EXPECT_TRUE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload)));
 }
 
 }  // namespace webrtc