Convert usage of ARRAY_SIZE to arraysize.

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 <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"
 
@@ skipping 630 matching lines @@
   // Test also with one way propagation delay = 100ms.
   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 = ARRAY_SIZE(kAllFlowIds);
+  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];
 
   // 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));
@@ skipping 91 matching lines @@
 // 5.7. RMCAT Flows competing with multiple short TCP Flows.
 void BweTest::RunMultipleShortTcpFairness(
     BandwidthEstimatorType bwe_type,
     std::vector<int> tcp_file_sizes_bytes,
     std::vector<int64_t> tcp_starting_times_ms) {
   // 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() == ARRAY_SIZE(kAllTcpFlowIds));
+         tcp_starting_times_ms.size() == arraysize(kAllTcpFlowIds));
 
-  const size_t kNumRmcatFlows = ARRAY_SIZE(kAllRmcatFlowIds);
-  const size_t kNumTotalFlows = kNumRmcatFlows + ARRAY_SIZE(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];
 
   // 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,
@@ skipping 71 matching lines @@
         title, bwe_names[bwe_type], kNumRmcatFlows,
         receivers[id].get()->GlobalPacketLoss());
     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 = ARRAY_SIZE(kAllFlowIds);
+  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];
 
   // Flows initialized simultaneously.
   const int64_t kStartingApartMs = 0;
 
   for (size_t i = 0; i < kNumFlows; ++i) {
@@ skipping 91 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