Refactor rtc_unittests into several targets.

webrtc/base/rate_limiter_unittest.cc

 /*
  *  Copyright (c) 2016 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 <algorithm>
 #include <memory>
 
 #include "webrtc/base/event.h"
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/base/rate_limiter.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 
 class RateLimitTest : public ::testing::Test {
  public:
   RateLimitTest()
       : clock_(0), rate_limiter(new RateLimiter(&clock_, kWindowSizeMs)) {}
-  virtual ~RateLimitTest() {}
+  ~RateLimitTest() override {}
 
   void SetUp() override { rate_limiter->SetMaxRate(kMaxRateBps); }
 
  protected:
   static constexpr int64_t kWindowSizeMs = 1000;
   static constexpr uint32_t kMaxRateBps = 100000;
   // Bytes needed to completely saturate the rate limiter.
   static constexpr size_t kRateFillingBytes =
       (kMaxRateBps * kWindowSizeMs) / (8 * 1000);
   SimulatedClock clock_;
@@ skipping 102 matching lines @@
   // Runs a few simple tasks, each on its own thread, but coordinated with
   // events so that they run in a serialized order. Intended to catch data
   // races when run with tsan et al.
 
   // Half window size, double rate -> same amount of bytes needed to fill rate.
 
   class SetWindowSizeTask : public ThreadTask {
    public:
     explicit SetWindowSizeTask(RateLimiter* rate_limiter)
         : ThreadTask(rate_limiter) {}
-    virtual ~SetWindowSizeTask() {}
+    ~SetWindowSizeTask() override {}
 
     void DoRun() override {
       EXPECT_TRUE(rate_limiter_->SetWindowSize(kWindowSizeMs / 2));
     }
   } set_window_size_task(rate_limiter.get());
   rtc::PlatformThread thread1(RunTask, &set_window_size_task, "Thread1");
   thread1.Start();
 
   class SetMaxRateTask : public ThreadTask {
    public:
     explicit SetMaxRateTask(RateLimiter* rate_limiter)
         : ThreadTask(rate_limiter) {}
-    virtual ~SetMaxRateTask() {}
+    ~SetMaxRateTask() override {}
 
     void DoRun() override { rate_limiter_->SetMaxRate(kMaxRateBps * 2); }
   } set_max_rate_task(rate_limiter.get());
   rtc::PlatformThread thread2(RunTask, &set_max_rate_task, "Thread2");
   thread2.Start();
 
   class UseRateTask : public ThreadTask {
    public:
     UseRateTask(RateLimiter* rate_limiter, SimulatedClock* clock)
         : ThreadTask(rate_limiter), clock_(clock) {}
-    virtual ~UseRateTask() {}
+    ~UseRateTask() override {}
 
     void DoRun() override {
       EXPECT_TRUE(rate_limiter_->TryUseRate(kRateFillingBytes / 2));
       clock_->AdvanceTimeMilliseconds((kWindowSizeMs / 2) - 1);
       EXPECT_TRUE(rate_limiter_->TryUseRate(kRateFillingBytes / 2));
     }
 
     SimulatedClock* const clock_;
   } use_rate_task(rate_limiter.get(), &clock_);
   rtc::PlatformThread thread3(RunTask, &use_rate_task, "Thread3");
@@ skipping 10 matching lines @@
 
   // All rate consumed.
   EXPECT_FALSE(rate_limiter->TryUseRate(1));
 
   thread1.Stop();
   thread2.Stop();
   thread3.Stop();
 }
 
 }  // namespace webrtc