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

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() {}
 
-  virtual SyncServiceState GetSyncServiceState() OVERRIDE {
+  virtual SyncServiceState GetSyncServiceState() override {
     return service_state_;
   }
 
-  virtual SyncFileSystemService* GetSyncService() OVERRIDE {
+  virtual 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() {}
 
-  virtual bool IsRunning() OVERRIDE {
+  virtual 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 {
+                     const base::Closure& closure) override {
     scheduled_time_ = current_time_ + delay;
     timer_task_ = closure;
   }
 
-  virtual base::TimeTicks Now() const OVERRIDE {
+  virtual 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();
@@ skipping 21 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 {
+  virtual void StartSync(const SyncStatusCallback& callback) override {
     EXPECT_LT(running_tasks_.size(), max_parallel_task_);
     running_tasks_.push(callback);
   }
 
   virtual ~FakeSyncProcessRunner() {
   }
 
   void UpdateChanges(int num_changes) {
     OnChangesUpdated(num_changes);
   }
@@ skipping 160 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