Replace the remaining scoped_ptr with unique_ptr in webrtc/modules/

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_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 "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 
 #include <limits>
+#include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 
 using webrtc::rtcp::TransportFeedback;
 
 namespace webrtc {
 namespace {
 
@@ skipping 12 matching lines @@
 
   void WithExpectedSize(size_t expected_size) {
     expected_size_ = expected_size;
   }
 
   void WithDefaultDelta(int64_t delta) { default_delta_ = delta; }
 
   void WithInput(const uint16_t received_seq[],
                  const int64_t received_ts[],
                  uint16_t length) {
-    rtc::scoped_ptr<int64_t[]> temp_deltas;
+    std::unique_ptr<int64_t[]> temp_deltas;
     if (received_ts == nullptr) {
       temp_deltas.reset(new int64_t[length]);
       GenerateDeltas(received_seq, length, temp_deltas.get());
       received_ts = temp_deltas.get();
     }
 
     expected_seq_.clear();
     expected_deltas_.clear();
     feedback_.reset(new TransportFeedback());
 
@@ skipping 72 matching lines @@
       last_seq = seq[i];
 
       deltas[i] = offset + (last_seq * default_delta_);
     }
   }
 
   std::vector<uint16_t> expected_seq_;
   std::vector<int64_t> expected_deltas_;
   size_t expected_size_;
   int64_t default_delta_;
-  rtc::scoped_ptr<TransportFeedback> feedback_;
+  std::unique_ptr<TransportFeedback> feedback_;
   rtc::Buffer serialized_;
 };
 
 TEST(RtcpPacketTest, TransportFeedback_OneBitVector) {
   const uint16_t kReceived[] = {1, 2, 7, 8, 9, 10, 13};
   const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
   const size_t kExpectedSizeBytes =
       kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);
 
   FeedbackTester test;
@@ skipping 199 matching lines @@
     int64_t expected_time = num_samples * kTooSmallDelta;
     ++num_samples;
 
     EXPECT_NEAR(expected_time, accumulated_delta,
                 TransportFeedback::kDeltaScaleFactor / 2);
   }
 }
 
 TEST(RtcpPacketTest, TransportFeedback_Limits) {
   // Sequence number wrap above 0x8000.
-  rtc::scoped_ptr<TransportFeedback> packet(new TransportFeedback());
+  std::unique_ptr<TransportFeedback> packet(new TransportFeedback());
   packet->WithBase(0, 0);
   EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000));
 
   packet.reset(new TransportFeedback());
   packet->WithBase(0, 0);
   EXPECT_FALSE(packet->WithReceivedPacket(0x8000 + 1, 1000));
 
   // Packet status count max 0xFFFF.
   packet.reset(new TransportFeedback());
   packet->WithBase(0, 0);
@@ skipping 69 matching lines @@
   uint8_t mod_buffer[kExpectedSizeWithPadding];
   memcpy(mod_buffer, packet.data(), kExpectedSizeWords * 4);
   memset(&mod_buffer[kExpectedSizeWords * 4], 0, kPaddingBytes - 1);
   mod_buffer[kExpectedSizeWithPadding - 1] = kPaddingBytes;
   const uint8_t padding_flag = 1 << 5;
   mod_buffer[0] |= padding_flag;
   ByteWriter<uint16_t>::WriteBigEndian(
       &mod_buffer[2], ByteReader<uint16_t>::ReadBigEndian(&mod_buffer[2]) +
                           ((kPaddingBytes + 3) / 4));
 
-  rtc::scoped_ptr<TransportFeedback> parsed_packet(
+  std::unique_ptr<TransportFeedback> parsed_packet(
       TransportFeedback::ParseFrom(mod_buffer, kExpectedSizeWithPadding));
   ASSERT_TRUE(parsed_packet.get() != nullptr);
   EXPECT_EQ(kExpectedSizeWords * 4, packet.size());  // Padding not included.
 }
 
 TEST(RtcpPacketTest, TransportFeedback_CorrectlySplitsVectorChunks) {
   const int kOneBitVectorCapacity = 14;
   const int64_t kLargeTimeDelta =
       TransportFeedback::kDeltaScaleFactor * (1 << 8);
 
   // Test that a number of small deltas followed by a large delta results in a
   // correct split into multiple chunks, as needed.
 
   for (int deltas = 0; deltas <= kOneBitVectorCapacity + 1; ++deltas) {
     TransportFeedback feedback;
     feedback.WithBase(0, 0);
     for (int i = 0; i < deltas; ++i)
       feedback.WithReceivedPacket(i, i * 1000);
     feedback.WithReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta);
 
     rtc::Buffer serialized_packet = feedback.Build();
-    rtc::scoped_ptr<TransportFeedback> deserialized_packet =
+    std::unique_ptr<TransportFeedback> deserialized_packet =
         TransportFeedback::ParseFrom(serialized_packet.data(),
                                      serialized_packet.size());
     EXPECT_TRUE(deserialized_packet.get() != nullptr);
   }
 }
 
 }  // namespace
 }  // namespace webrtc