Fixed lint warnings in webrtc/modules/remote_bitrate_estimator

webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimators_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.
  */
 
 #ifndef WEBRTC_WIN
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
+#include <algorithm>
 #include <sstream>
 
+#include "webrtc/base/random.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/packet_receiver.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/packet_sender.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 using std::string;
 
 namespace webrtc {
 namespace testing {
@@ skipping 207 matching lines @@
   jitter.SetMaxJitter(120);
   RunFor(5 * 60 * 1000);
 }
 
 // This test fixture is used to instantiate tests running with adaptive video
 // senders.
 class BweFeedbackTest
     : public BweTest,
       public ::testing::TestWithParam<BandwidthEstimatorType> {
  public:
-  BweFeedbackTest() : BweTest() {}
+#ifdef WEBRTC_WIN
+  BweFeedbackTest()
+      : BweTest(), random_(Clock::GetRealTimeClock()->TimeInMicroseconds()) {}
+#else
+  BweFeedbackTest()
+      : BweTest(),
+        // Multiply the time by a random-ish odd number derived from the PID.
+        random_((getpid() | 1) *
+                Clock::GetRealTimeClock()->TimeInMicroseconds()) {}
+#endif
   virtual ~BweFeedbackTest() {}
 
  protected:
-  void SetUp() override {
-    unsigned int seed = Clock::GetRealTimeClock()->TimeInMicroseconds();
-#ifndef WEBRTC_WIN
-    seed *= getpid();
-#endif
-    srand(seed);
-    BweTest::SetUp();
-  }
+  Random random_;
 
  private:
   RTC_DISALLOW_COPY_AND_ASSIGN(BweFeedbackTest);
 };
 
 INSTANTIATE_TEST_CASE_P(VideoSendersTest,
                         BweFeedbackTest,
                         ::testing::Values(kRembEstimator,
                                           kFullSendSideEstimator));
 
@@ skipping 82 matching lines @@
                0, receiver.GetDelayStats(), counter2.GetBitrateStats());
 }
 
 TEST_P(BweFeedbackTest, PacedSelfFairness50msTest) {
   int64_t kRttMs = 100;
   int64_t kMaxJitterMs = 15;
 
   const int kNumRmcatFlows = 4;
   int64_t offset_ms[kNumRmcatFlows];
   for (int i = 0; i < kNumRmcatFlows; ++i) {
-    offset_ms[i] = std::max(0, 5000 * i + rand() % 2001 - 1000);
+    offset_ms[i] = std::max(0, 5000 * i + random_.Rand(-1000, 1000));
   }
 
   RunFairnessTest(GetParam(), kNumRmcatFlows, 0, 300, 3000, 50, kRttMs,
                   kMaxJitterMs, offset_ms);
 }
 
 TEST_P(BweFeedbackTest, PacedSelfFairness500msTest) {
   int64_t kRttMs = 100;
   int64_t kMaxJitterMs = 15;
 
   const int kNumRmcatFlows = 4;
   int64_t offset_ms[kNumRmcatFlows];
   for (int i = 0; i < kNumRmcatFlows; ++i) {
-    offset_ms[i] = std::max(0, 5000 * i + rand() % 2001 - 1000);
+    offset_ms[i] = std::max(0, 5000 * i + random_.Rand(-1000, 1000));
   }
 
   RunFairnessTest(GetParam(), kNumRmcatFlows, 0, 300, 3000, 500, kRttMs,
                   kMaxJitterMs, offset_ms);
 }
 
 TEST_P(BweFeedbackTest, PacedSelfFairness1000msTest) {
   int64_t kRttMs = 100;
   int64_t kMaxJitterMs = 15;
 
   const int kNumRmcatFlows = 4;
   int64_t offset_ms[kNumRmcatFlows];
   for (int i = 0; i < kNumRmcatFlows; ++i) {
-    offset_ms[i] = std::max(0, 5000 * i + rand() % 2001 - 1000);
+    offset_ms[i] = std::max(0, 5000 * i + random_.Rand(-1000, 1000));
   }
 
   RunFairnessTest(GetParam(), kNumRmcatFlows, 0, 300, 3000, 1000, kRttMs,
                   kMaxJitterMs, offset_ms);
 }
 
 TEST_P(BweFeedbackTest, TcpFairness50msTest) {
   int64_t kRttMs = 100;
   int64_t kMaxJitterMs = 15;
 
   int64_t offset_ms[2];  // One TCP, one RMCAT flow.
   for (int i = 0; i < 2; ++i) {
-    offset_ms[i] = std::max(0, 5000 * i + rand() % 2001 - 1000);
+    offset_ms[i] = std::max(0, 5000 * i + random_.Rand(-1000, 1000));
   }
 
   RunFairnessTest(GetParam(), 1, 1, 300, 2000, 50, kRttMs, kMaxJitterMs,
                   offset_ms);
 }
 
 TEST_P(BweFeedbackTest, TcpFairness500msTest) {
   int64_t kRttMs = 100;
   int64_t kMaxJitterMs = 15;
 
   int64_t offset_ms[2];  // One TCP, one RMCAT flow.
   for (int i = 0; i < 2; ++i) {
-    offset_ms[i] = std::max(0, 5000 * i + rand() % 2001 - 1000);
+    offset_ms[i] = std::max(0, 5000 * i + random_.Rand(-1000, 1000));
   }
 
   RunFairnessTest(GetParam(), 1, 1, 300, 2000, 500, kRttMs, kMaxJitterMs,
                   offset_ms);
 }
 
 TEST_P(BweFeedbackTest, TcpFairness1000msTest) {
   int64_t kRttMs = 100;
   int64_t kMaxJitterMs = 15;
 
   int64_t offset_ms[2];  // One TCP, one RMCAT flow.
   for (int i = 0; i < 2; ++i) {
-    offset_ms[i] = std::max(0, 5000 * i + rand() % 2001 - 1000);
+    offset_ms[i] = std::max(0, 5000 * i + random_.Rand(-1000, 1000));
   }
 
   RunFairnessTest(GetParam(), 1, 1, 300, 2000, 1000, kRttMs, kMaxJitterMs,
                   offset_ms);
 }
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc