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

chrome/browser/sync_file_system/drive_backend/sync_task_manager_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 <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 49 matching lines @@
         task_scheduled_count_(0),
         idle_task_scheduled_count_(0),
         last_operation_status_(SYNC_STATUS_OK) {
     task_manager_.reset(new SyncTaskManager(
         AsWeakPtr(), maximum_background_task,
         base::ThreadTaskRunnerHandle::Get()));
     task_manager_->Initialize(SYNC_STATUS_OK);
     base::MessageLoop::current()->RunUntilIdle();
     maybe_schedule_next_task_count_ = 0;
   }
-  virtual ~TaskManagerClient() {}
+  ~TaskManagerClient() override {}
 
   // DriveFileSyncManager::Client overrides.
-  virtual void MaybeScheduleNextTask() override {
-    ++maybe_schedule_next_task_count_;
-  }
-  virtual void NotifyLastOperationStatus(
-      SyncStatusCode last_operation_status,
-      bool last_operation_used_network) override {
+  void MaybeScheduleNextTask() override { ++maybe_schedule_next_task_count_; }
+  void NotifyLastOperationStatus(SyncStatusCode last_operation_status,
+                                 bool last_operation_used_network) override {
     last_operation_status_ = last_operation_status;
   }
 
-  virtual void RecordTaskLog(scoped_ptr<TaskLogger::TaskLog>) override {}
+  void RecordTaskLog(scoped_ptr<TaskLogger::TaskLog>) override {}
 
   void ScheduleTask(SyncStatusCode status_to_return,
                     const SyncStatusCallback& callback) {
     task_manager_->ScheduleTask(
         FROM_HERE,
         base::Bind(&TaskManagerClient::DoTask, AsWeakPtr(),
                    status_to_return, false /* idle */),
         SyncTaskManager::PRIORITY_MED,
         callback);
   }
@@ skipping 41 matching lines @@
  public:
   MultihopSyncTask(bool* task_started,
                    bool* task_completed)
       : task_started_(task_started),
         task_completed_(task_completed),
         weak_ptr_factory_(this) {
     DCHECK(task_started_);
     DCHECK(task_completed_);
   }
 
-  virtual ~MultihopSyncTask() {}
+  ~MultihopSyncTask() override {}
 
-  virtual void RunExclusive(const SyncStatusCallback& callback) override {
+  void RunExclusive(const SyncStatusCallback& callback) override {
     DCHECK(!*task_started_);
     *task_started_ = true;
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&MultihopSyncTask::CompleteTask,
                               weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
  private:
   void CompleteTask(const SyncStatusCallback& callback) {
     DCHECK(*task_started_);
@@ skipping 24 matching lines @@
 
   BackgroundTask(const std::string& app_id,
                  const base::FilePath& path,
                  Stats* stats)
       : app_id_(app_id),
         path_(path),
         stats_(stats),
         weak_ptr_factory_(this) {
   }
 
-  virtual ~BackgroundTask() {
-  }
+  ~BackgroundTask() override {}
 
-  virtual void RunPreflight(scoped_ptr<SyncTaskToken> token) override {
+  void RunPreflight(scoped_ptr<SyncTaskToken> token) override {
     scoped_ptr<TaskBlocker> task_blocker(new TaskBlocker);
     task_blocker->app_id = app_id_;
     task_blocker->paths.push_back(path_);
 
     SyncTaskManager::UpdateTaskBlocker(
         token.Pass(), task_blocker.Pass(),
         base::Bind(&BackgroundTask::RunAsBackgroundTask,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
@@ skipping 33 matching lines @@
                           const std::string& app_id,
                           const std::vector<std::string>& paths,
                           Log* log)
       : name_(name),
         app_id_(app_id),
         paths_(paths.begin(), paths.end()),
         log_(log),
         weak_ptr_factory_(this) {
   }
 
-  virtual ~BlockerUpdateTestHelper() {
-  }
+  ~BlockerUpdateTestHelper() override {}
 
-  virtual void RunPreflight(scoped_ptr<SyncTaskToken> token) override {
+  void RunPreflight(scoped_ptr<SyncTaskToken> token) override {
     UpdateBlocker(token.Pass());
   }
 
  private:
   void UpdateBlocker(scoped_ptr<SyncTaskToken> token) {
     if (paths_.empty()) {
       log_->push_back(name_ + ": finished");
       SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
       return;
     }
@@ skipping 405 matching lines @@
 
   EXPECT_EQ("task1: finished", log[i++]);
 
   EXPECT_EQ("task2: updating to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task2: updated to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task2: finished", log[i++]);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system