replace OVERRIDE and FINAL with override and final in chrome/browser/[r-z]*

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 52 matching lines @@
     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() {}
 
   // DriveFileSyncManager::Client overrides.
-  virtual void MaybeScheduleNextTask() OVERRIDE {
+  virtual void MaybeScheduleNextTask() override {
     ++maybe_schedule_next_task_count_;
   }
   virtual void NotifyLastOperationStatus(
       SyncStatusCode last_operation_status,
-      bool last_operation_used_network) OVERRIDE {
+      bool last_operation_used_network) override {
     last_operation_status_ = last_operation_status;
   }
 
-  virtual void RecordTaskLog(scoped_ptr<TaskLogger::TaskLog>) OVERRIDE {}
+  virtual 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 43 matching lines @@
                    bool* task_completed)
       : task_started_(task_started),
         task_completed_(task_completed),
         weak_ptr_factory_(this) {
     DCHECK(task_started_);
     DCHECK(task_completed_);
   }
 
   virtual ~MultihopSyncTask() {}
 
-  virtual void RunExclusive(const SyncStatusCallback& callback) OVERRIDE {
+  virtual 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 27 matching lines @@
                  Stats* stats)
       : app_id_(app_id),
         path_(path),
         stats_(stats),
         weak_ptr_factory_(this) {
   }
 
   virtual ~BackgroundTask() {
   }
 
-  virtual void RunPreflight(scoped_ptr<SyncTaskToken> token) OVERRIDE {
+  virtual 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 36 matching lines @@
       : name_(name),
         app_id_(app_id),
         paths_(paths.begin(), paths.end()),
         log_(log),
         weak_ptr_factory_(this) {
   }
 
   virtual ~BlockerUpdateTestHelper() {
   }
 
-  virtual void RunPreflight(scoped_ptr<SyncTaskToken> token) OVERRIDE {
+  virtual 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