Replace scoped_ptr with unique_ptr in webrtc/modules/remote_bitrate_estimator/

webrtc/modules/remote_bitrate_estimator/test/bwe_test.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 "webrtc/modules/remote_bitrate_estimator/test/bwe_test.h"
 
+#include <memory>
 #include <sstream>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/common.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/metric_recorder.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/packet_sender.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/testsupport/perf_test.h"
 
 using std::string;
 using std::vector;
@@ skipping 520 matching lines @@
   for (MetricRecorder* recorder : metric_recorders)
     delete recorder;
   for (PacketReceiver* receiver : receivers)
     delete receiver;
 }
 
 // 5.3. Bi-directional RMCAT flows.
 void BweTest::RunBidirectionalFlow(BandwidthEstimatorType bwe_type) {
   enum direction { kForward = 0, kBackward };
   const size_t kNumFlows = 2;
-  rtc::scoped_ptr<AdaptiveVideoSource> sources[kNumFlows];
-  rtc::scoped_ptr<VideoSender> senders[kNumFlows];
-  rtc::scoped_ptr<MetricRecorder> metric_recorders[kNumFlows];
-  rtc::scoped_ptr<PacketReceiver> receivers[kNumFlows];
+  std::unique_ptr<AdaptiveVideoSource> sources[kNumFlows];
+  std::unique_ptr<VideoSender> senders[kNumFlows];
+  std::unique_ptr<MetricRecorder> metric_recorders[kNumFlows];
+  std::unique_ptr<PacketReceiver> receivers[kNumFlows];
 
   sources[kForward].reset(new AdaptiveVideoSource(kForward, 30, 300, 0, 0));
   senders[kForward].reset(
       new VideoSender(&uplink_, sources[kForward].get(), bwe_type));
 
   sources[kBackward].reset(new AdaptiveVideoSource(kBackward, 30, 300, 0, 0));
   senders[kBackward].reset(
       new VideoSender(&downlink_, sources[kBackward].get(), bwe_type));
 
   DefaultEvaluationFilter up_filter(&uplink_, kForward);
@@ skipping 85 matching lines @@
   RunFairnessTest(bwe_type, kNumRmcatFlows, kNumTcpFlows, kRunTimeS,
                   kLinkCapacity, max_delay_ms, rtt_ms, kMaxJitterMs, offsets_ms,
                   title, bwe_names[bwe_type]);
 }
 
 // 5.5. Five competing RMCAT flows under different RTTs.
 void BweTest::RunRoundTripTimeFairness(BandwidthEstimatorType bwe_type) {
   const int kAllFlowIds[] = {0, 1, 2, 3, 4};  // Five RMCAT flows.
   const int64_t kAllOneWayDelayMs[] = {10, 25, 50, 100, 150};
   const size_t kNumFlows = arraysize(kAllFlowIds);
-  rtc::scoped_ptr<AdaptiveVideoSource> sources[kNumFlows];
-  rtc::scoped_ptr<VideoSender> senders[kNumFlows];
-  rtc::scoped_ptr<MetricRecorder> metric_recorders[kNumFlows];
+  std::unique_ptr<AdaptiveVideoSource> sources[kNumFlows];
+  std::unique_ptr<VideoSender> senders[kNumFlows];
+  std::unique_ptr<MetricRecorder> metric_recorders[kNumFlows];
 
   // Flows initialized 10 seconds apart.
   const int64_t kStartingApartMs = 10 * 1000;
 
   for (size_t i = 0; i < kNumFlows; ++i) {
     sources[i].reset(new AdaptiveVideoSource(kAllFlowIds[i], 30, 300, 0,
                                              i * kStartingApartMs));
     senders[i].reset(new VideoSender(&uplink_, sources[i].get(), bwe_type));
   }
 
   ChokeFilter choke_filter(&uplink_, CreateFlowIds(kAllFlowIds, kNumFlows));
   LinkShare link_share(&choke_filter);
 
   JitterFilter jitter_filter(&uplink_, CreateFlowIds(kAllFlowIds, kNumFlows));
 
-  rtc::scoped_ptr<DelayFilter> up_delay_filters[kNumFlows];
+  std::unique_ptr<DelayFilter> up_delay_filters[kNumFlows];
   for (size_t i = 0; i < kNumFlows; ++i) {
     up_delay_filters[i].reset(new DelayFilter(&uplink_, kAllFlowIds[i]));
   }
 
   RateCounterFilter total_utilization(
       &uplink_, CreateFlowIds(kAllFlowIds, kNumFlows), "Total_utilization",
       "Total_link_utilization");
 
   // Delays is being plotted only for the first flow.
   // To plot all of them, replace "i == 0" with "true" on new PacketReceiver().
-  rtc::scoped_ptr<PacketReceiver> receivers[kNumFlows];
+  std::unique_ptr<PacketReceiver> receivers[kNumFlows];
   for (size_t i = 0; i < kNumFlows; ++i) {
     metric_recorders[i].reset(
         new MetricRecorder(bwe_names[bwe_type], static_cast<int>(i),
                            senders[i].get(), &link_share));
 
     receivers[i].reset(new PacketReceiver(&uplink_, kAllFlowIds[i], bwe_type,
                                           i == 0, false,
                                           metric_recorders[i].get()));
     metric_recorders[i].get()->set_start_computing_metrics_ms(kStartingApartMs *
                                                               (kNumFlows - 1));
     metric_recorders[i].get()->set_plot_available_capacity(
         i == 0 && plot_total_available_capacity_);
   }
 
-  rtc::scoped_ptr<DelayFilter> down_delay_filters[kNumFlows];
+  std::unique_ptr<DelayFilter> down_delay_filters[kNumFlows];
   for (size_t i = 0; i < kNumFlows; ++i) {
     down_delay_filters[i].reset(new DelayFilter(&downlink_, kAllFlowIds[i]));
   }
 
   jitter_filter.SetMaxJitter(kMaxJitterMs);
   choke_filter.set_max_delay_ms(kMaxQueueingDelayMs);
 
   for (size_t i = 0; i < kNumFlows; ++i) {
     up_delay_filters[i]->SetOneWayDelayMs(kAllOneWayDelayMs[i]);
     down_delay_filters[i]->SetOneWayDelayMs(kAllOneWayDelayMs[i]);
@@ skipping 51 matching lines @@
   // Two RMCAT flows and ten TCP flows.
   const int kAllRmcatFlowIds[] = {0, 1};
   const int kAllTcpFlowIds[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
 
   assert(tcp_starting_times_ms.size() == tcp_file_sizes_bytes.size() &&
          tcp_starting_times_ms.size() == arraysize(kAllTcpFlowIds));
 
   const size_t kNumRmcatFlows = arraysize(kAllRmcatFlowIds);
   const size_t kNumTotalFlows = kNumRmcatFlows + arraysize(kAllTcpFlowIds);
 
-  rtc::scoped_ptr<AdaptiveVideoSource> sources[kNumRmcatFlows];
-  rtc::scoped_ptr<PacketSender> senders[kNumTotalFlows];
-  rtc::scoped_ptr<MetricRecorder> metric_recorders[kNumTotalFlows];
-  rtc::scoped_ptr<PacketReceiver> receivers[kNumTotalFlows];
+  std::unique_ptr<AdaptiveVideoSource> sources[kNumRmcatFlows];
+  std::unique_ptr<PacketSender> senders[kNumTotalFlows];
+  std::unique_ptr<MetricRecorder> metric_recorders[kNumTotalFlows];
+  std::unique_ptr<PacketReceiver> receivers[kNumTotalFlows];
 
   // RMCAT Flows are initialized simultaneosly at t=5 seconds.
   const int64_t kRmcatStartingTimeMs = 5 * 1000;
   for (size_t id : kAllRmcatFlowIds) {
     sources[id].reset(new AdaptiveVideoSource(static_cast<int>(id), 30, 300, 0,
                                               kRmcatStartingTimeMs));
     senders[id].reset(new VideoSender(&uplink_, sources[id].get(), bwe_type));
   }
 
   for (size_t id : kAllTcpFlowIds) {
@@ skipping 68 matching lines @@
     BWE_TEST_LOGGING_BASELINEBAR(5, bwe_names[bwe_type], kOneWayDelayMs, id);
   }
 }
 
 // 5.8. Three forward direction competing flows, constant capacity.
 // During the test, one of the flows is paused and later resumed.
 void BweTest::RunPauseResumeFlows(BandwidthEstimatorType bwe_type) {
   const int kAllFlowIds[] = {0, 1, 2};  // Three RMCAT flows.
   const size_t kNumFlows = arraysize(kAllFlowIds);
 
-  rtc::scoped_ptr<AdaptiveVideoSource> sources[kNumFlows];
-  rtc::scoped_ptr<VideoSender> senders[kNumFlows];
-  rtc::scoped_ptr<MetricRecorder> metric_recorders[kNumFlows];
-  rtc::scoped_ptr<PacketReceiver> receivers[kNumFlows];
+  std::unique_ptr<AdaptiveVideoSource> sources[kNumFlows];
+  std::unique_ptr<VideoSender> senders[kNumFlows];
+  std::unique_ptr<MetricRecorder> metric_recorders[kNumFlows];
+  std::unique_ptr<PacketReceiver> receivers[kNumFlows];
 
   // Flows initialized simultaneously.
   const int64_t kStartingApartMs = 0;
 
   for (size_t i = 0; i < kNumFlows; ++i) {
     sources[i].reset(new AdaptiveVideoSource(kAllFlowIds[i], 30, 300, 0,
                                              i * kStartingApartMs));
     senders[i].reset(new VideoSender(&uplink_, sources[i].get(), bwe_type));
   }
 
@@ skipping 86 matching lines @@
     tcp_starting_times_ms.push_back(
         static_cast<int64_t>(random.Exponential(1.0f / kMeanMs)));
   }
 
   return tcp_starting_times_ms;
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc