Standardize usage of virtual/override/final in chrome/browser/sync_file_system/

chrome/browser/sync_file_system/sync_process_runner_unittest.cc

 // Copyright 2014 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.
 
 #include "chrome/browser/sync_file_system/sync_process_runner.h"
 
 #include <queue>
 
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sync_file_system {
 
 namespace {
 
 class FakeClient : public SyncProcessRunner::Client {
  public:
   FakeClient() : service_state_(SYNC_SERVICE_RUNNING) {}
-  virtual ~FakeClient() {}
+  ~FakeClient() override {}
 
-  virtual SyncServiceState GetSyncServiceState() override {
-    return service_state_;
-  }
+  SyncServiceState GetSyncServiceState() override { return service_state_; }
 
-  virtual SyncFileSystemService* GetSyncService() override {
-    return nullptr;
-  }
+  SyncFileSystemService* GetSyncService() override { return nullptr; }
 
   void set_service_state(SyncServiceState service_state) {
     service_state_ = service_state;
   }
 
  private:
   SyncServiceState service_state_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeClient);
 };
 
 class FakeTimerHelper : public SyncProcessRunner::TimerHelper {
  public:
   FakeTimerHelper() {}
-  virtual ~FakeTimerHelper() {}
+  ~FakeTimerHelper() override {}
 
-  virtual bool IsRunning() override {
-    return !timer_task_.is_null();
-  }
+  bool IsRunning() override { return !timer_task_.is_null(); }
 
-  virtual void Start(const tracked_objects::Location& from_here,
-                     const base::TimeDelta& delay,
-                     const base::Closure& closure) override {
+  void Start(const tracked_objects::Location& from_here,
+             const base::TimeDelta& delay,
+             const base::Closure& closure) override {
     scheduled_time_ = current_time_ + delay;
     timer_task_ = closure;
   }
 
-  virtual base::TimeTicks Now() const override {
-    return current_time_;
-  }
+  base::TimeTicks Now() const override { return current_time_; }
 
   void SetCurrentTime(const base::TimeTicks& current_time) {
     current_time_ = current_time;
     if (current_time_ < scheduled_time_ || timer_task_.is_null())
       return;
 
     base::Closure task = timer_task_;
     timer_task_.Reset();
     task.Run();
   }
@@ skipping 19 matching lines @@
  public:
   FakeSyncProcessRunner(SyncProcessRunner::Client* client,
                         scoped_ptr<TimerHelper> timer_helper,
                         size_t max_parallel_task)
       : SyncProcessRunner("FakeSyncProcess",
                           client, timer_helper.Pass(),
                           max_parallel_task),
         max_parallel_task_(max_parallel_task) {
   }
 
-  virtual void StartSync(const SyncStatusCallback& callback) override {
+  void StartSync(const SyncStatusCallback& callback) override {
     EXPECT_LT(running_tasks_.size(), max_parallel_task_);
     running_tasks_.push(callback);
   }
 
-  virtual ~FakeSyncProcessRunner() {
-  }
+  ~FakeSyncProcessRunner() override {}
 
   void UpdateChanges(int num_changes) {
     OnChangesUpdated(num_changes);
   }
 
   void CompleteTask(SyncStatusCode status) {
     ASSERT_FALSE(running_tasks_.empty());
     SyncStatusCallback task = running_tasks_.front();
     running_tasks_.pop();
     task.Run(status);
@@ skipping 154 matching lines @@
 
   // Then, following failing task should not extend throttling period.
   fake_timer->AdvanceToScheduledTime();
   fake_client.set_service_state(SYNC_SERVICE_TEMPORARY_UNAVAILABLE);
   fake_runner.CompleteTask(SYNC_STATUS_FAILED);
   EXPECT_EQ(SyncProcessRunner::kSyncDelaySlowInMilliseconds,
             fake_timer->GetCurrentDelay());
 }
 
 }  // namespace sync_file_system