Replace scoped_ptr with unique_ptr in webrtc/modules/remote_bitrate_estimator/

webrtc/modules/remote_bitrate_estimator/test/estimators/nada_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/remote_bitrate_estimator/test/estimators/nada.h"
 
 #include <algorithm>
+#include <memory>
 #include <numeric>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/common.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/packet.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/packet_sender.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 namespace webrtc {
 namespace testing {
 namespace bwe {
@@ skipping 278 matching lines @@
 
   for (int i = 0; i < 100; ++i) {
     int previous_bitrate = nada_sender_.bitrate_kbps();
     nada_sender_.GiveFeedback(not_congested_fb);
     EXPECT_GE(nada_sender_.bitrate_kbps(), previous_bitrate);
   }
   EXPECT_EQ(nada_sender_.bitrate_kbps(), kMaxBitrateKbps);
 }
 
 TEST_F(NadaReceiverSideTest, FeedbackInitialCases) {
-  rtc::scoped_ptr<NadaFeedback> nada_feedback(
+  std::unique_ptr<NadaFeedback> nada_feedback(
       static_cast<NadaFeedback*>(nada_receiver_.GetFeedback(0)));
   EXPECT_EQ(nada_feedback, nullptr);
 
   nada_feedback.reset(
       static_cast<NadaFeedback*>(nada_receiver_.GetFeedback(100)));
   EXPECT_EQ(nada_feedback->exp_smoothed_delay_ms(), -1);
   EXPECT_EQ(nada_feedback->est_queuing_delay_signal_ms(), 0L);
   EXPECT_EQ(nada_feedback->congestion_signal(), 0L);
   EXPECT_EQ(nada_feedback->derivative(), 0.0f);
   EXPECT_EQ(nada_feedback->receiving_rate(), 0.0f);
 }
 
 TEST_F(NadaReceiverSideTest, FeedbackEmptyQueues) {
   const int64_t kTimeGapMs = 50;  // Between each packet.
   const int64_t kOneWayDelayMs = 50;
 
   // No added latency, delay = kOneWayDelayMs.
   for (int i = 1; i < 10; ++i) {
     int64_t send_time_us = i * kTimeGapMs * 1000;
     int64_t arrival_time_ms = send_time_us / 1000 + kOneWayDelayMs;
     uint16_t sequence_number = static_cast<uint16_t>(i);
     // Payload sizes are not important here.
     const MediaPacket media_packet(kFlowId, send_time_us, 0, sequence_number);
     nada_receiver_.ReceivePacket(arrival_time_ms, media_packet);
   }
 
   // Baseline delay will be equal kOneWayDelayMs.
-  rtc::scoped_ptr<NadaFeedback> nada_feedback(
+  std::unique_ptr<NadaFeedback> nada_feedback(
       static_cast<NadaFeedback*>(nada_receiver_.GetFeedback(500)));
   EXPECT_EQ(nada_feedback->exp_smoothed_delay_ms(), 0L);
   EXPECT_EQ(nada_feedback->est_queuing_delay_signal_ms(), 0L);
   EXPECT_EQ(nada_feedback->congestion_signal(), 0L);
   EXPECT_EQ(nada_feedback->derivative(), 0.0f);
 }
 
 TEST_F(NadaReceiverSideTest, FeedbackIncreasingDelay) {
   // Since packets are 100ms apart, each one corresponds to a feedback.
   const int64_t kTimeGapMs = 100;  // Between each packet.
@@ skipping 15 matching lines @@
   }
 
   for (int i = 0; i < kNumPackets; ++i) {
     int64_t send_time_us = (i + 1) * kTimeGapMs * 1000;
     int64_t arrival_time_ms = send_time_us / 1000 + 10 * (i + 1);
     uint16_t sequence_number = static_cast<uint16_t>(i + 1);
     // Payload sizes are not important here.
     const MediaPacket media_packet(kFlowId, send_time_us, 0, sequence_number);
     nada_receiver_.ReceivePacket(arrival_time_ms, media_packet);
 
-    rtc::scoped_ptr<NadaFeedback> nada_feedback(static_cast<NadaFeedback*>(
+    std::unique_ptr<NadaFeedback> nada_feedback(static_cast<NadaFeedback*>(
         nada_receiver_.GetFeedback(arrival_time_ms)));
     EXPECT_EQ(nada_feedback->exp_smoothed_delay_ms(),
               exp_smoothed_delays_ms[i]);
     // Since delay signals are lower than 50ms, they will not be non-linearly
     // warped.
     EXPECT_EQ(nada_feedback->est_queuing_delay_signal_ms(),
               exp_smoothed_delays_ms[i]);
     // Zero loss, congestion signal = queuing_delay
     EXPECT_EQ(nada_feedback->congestion_signal(), exp_smoothed_delays_ms[i]);
     if (i == 0) {
@@ skipping 48 matching lines @@
   }
 
   for (int i = 0; i < kNumPackets; ++i) {
     int64_t send_time_us = (i + 1) * kTimeGapMs * 1000;
     int64_t arrival_time_ms = send_time_us / 1000 + 50 + 200 * i;
     uint16_t sequence_number = static_cast<uint16_t>(i + 1);
     // Payload sizes are not important here.
     const MediaPacket media_packet(kFlowId, send_time_us, 0, sequence_number);
     nada_receiver_.ReceivePacket(arrival_time_ms, media_packet);
 
-    rtc::scoped_ptr<NadaFeedback> nada_feedback(static_cast<NadaFeedback*>(
+    std::unique_ptr<NadaFeedback> nada_feedback(static_cast<NadaFeedback*>(
         nada_receiver_.GetFeedback(arrival_time_ms)));
     EXPECT_EQ(nada_feedback->exp_smoothed_delay_ms(),
               exp_smoothed_delays_ms[i]);
     // Delays can be non-linearly warped.
     EXPECT_EQ(nada_feedback->est_queuing_delay_signal_ms(),
               Warp(exp_smoothed_delays_ms[i]));
     // Zero loss, congestion signal = queuing_delay
     EXPECT_EQ(nada_feedback->congestion_signal(),
               Warp(exp_smoothed_delays_ms[i]));
   }
@@ skipping 26 matching lines @@
   for (int i = 1; i < kNumElements; ++i) {
     EXPECT_EQ(
         exp_smoothed[i],
         static_cast<int64_t>(exp_smoothed[i - 1] * (1.0f - kAlpha) + 0.5f));
   }
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc