Standardize usage of virtual/override/final in net/

net/url_request/url_request_throttler_simulation_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The tests in this file attempt to verify the following through simulation:
 // a) That a server experiencing overload will actually benefit from the
 //    anti-DDoS throttling logic, i.e. that its traffic spike will subside
 //    and be distributed over a longer period of time;
 // b) That "well-behaved" clients of a server under DDoS attack actually
 //    benefit from the anti-DDoS throttling logic; and
@@ skipping 117 matching lines @@
         num_overloaded_ticks_(0),
         max_experienced_queries_per_tick_(0),
         mock_request_(context_.CreateRequest(
             GURL(), DEFAULT_PRIORITY, NULL, NULL)) {}
 
   void SetDowntime(const TimeTicks& start_time, const TimeDelta& duration) {
     start_downtime_ = start_time;
     end_downtime_ = start_time + duration;
   }
 
-  virtual void AdvanceTime(const TimeTicks& absolute_time) override {
+  void AdvanceTime(const TimeTicks& absolute_time) override {
     now_ = absolute_time;
   }
 
-  virtual void PerformAction() override {
+  void PerformAction() override {
     // We are inserted at the end of the actor's list, so all Requester
     // instances have already done their bit.
     if (num_current_tick_queries_ > max_experienced_queries_per_tick_)
       max_experienced_queries_per_tick_ = num_current_tick_queries_;
 
     if (num_current_tick_queries_ > max_queries_per_tick_) {
       // We pretend the server fails for the next several ticks after it
       // gets overloaded.
       num_overloaded_ticks_remaining_ = 5;
       ++num_overloaded_ticks_;
@@ skipping 146 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Server);
 };
 
 // Mock throttler entry used by Requester class.
 class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
  public:
   explicit MockURLRequestThrottlerEntry(URLRequestThrottlerManager* manager)
       : URLRequestThrottlerEntry(manager, std::string()),
         mock_backoff_entry_(&backoff_policy_) {}
 
-  virtual const BackoffEntry* GetBackoffEntry() const override {
+  const BackoffEntry* GetBackoffEntry() const override {
     return &mock_backoff_entry_;
   }
 
-  virtual BackoffEntry* GetBackoffEntry() override {
-    return &mock_backoff_entry_;
-  }
+  BackoffEntry* GetBackoffEntry() override { return &mock_backoff_entry_; }
 
-  virtual TimeTicks ImplGetTimeNow() const override {
-    return fake_now_;
-  }
+  TimeTicks ImplGetTimeNow() const override { return fake_now_; }
 
   void SetFakeNow(const TimeTicks& fake_time) {
     fake_now_ = fake_time;
     mock_backoff_entry_.set_fake_now(fake_time);
   }
 
   TimeTicks fake_now() const {
     return fake_now_;
   }
 
  protected:
-  virtual ~MockURLRequestThrottlerEntry() {}
+  ~MockURLRequestThrottlerEntry() override {}
 
  private:
   TimeTicks fake_now_;
   MockBackoffEntry mock_backoff_entry_;
 };
 
 // Registry of results for a class of |Requester| objects (e.g. attackers vs.
 // regular clients).
 class RequesterResults {
  public:
@@ skipping 65 matching lines @@
             Server* server,
             RequesterResults* results)
       : throttler_entry_(throttler_entry),
         time_between_requests_(time_between_requests),
         last_attempt_was_failure_(false),
         server_(server),
         results_(results) {
     DCHECK(server_);
   }
 
-  virtual void AdvanceTime(const TimeTicks& absolute_time) override {
+  void AdvanceTime(const TimeTicks& absolute_time) override {
     if (time_of_last_success_.is_null())
       time_of_last_success_ = absolute_time;
 
     throttler_entry_->SetFakeNow(absolute_time);
   }
 
-  virtual void PerformAction() override {
+  void PerformAction() override {
     TimeDelta effective_delay = time_between_requests_;
     TimeDelta current_jitter = TimeDelta::FromMilliseconds(
         request_jitter_.InMilliseconds() * base::RandDouble());
     if (base::RandInt(0, 1)) {
       effective_delay -= current_jitter;
     } else {
       effective_delay += current_jitter;
     }
 
     if (throttler_entry_->fake_now() - time_of_last_attempt_ >
@@ skipping 318 matching lines @@
     trials[i].PrintTrialDescription();
     trials[i].stats.ReportTrialResult(increase_ratio);
   }
 
   VerboseOut("Average increase ratio was %.4f\n", average_increase_ratio);
   VerboseOut("Maximum increase ratio was %.4f\n", max_increase_ratio);
 }
 
 }  // namespace
 }  // namespace net