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

chrome/browser/sync_file_system/drive_backend/sync_worker_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/drive_backend/sync_worker.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 29 matching lines @@
 
 }  // namespace
 
 class MockSyncTask : public ExclusiveTask {
  public:
   explicit MockSyncTask(bool used_network) {
     set_used_network(used_network);
   }
   virtual ~MockSyncTask() {}
 
-  virtual void RunExclusive(const SyncStatusCallback& callback) OVERRIDE {
+  virtual void RunExclusive(const SyncStatusCallback& callback) override {
     callback.Run(SYNC_STATUS_OK);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockSyncTask);
 };
 
 class MockExtensionService : public TestExtensionService {
  public:
   MockExtensionService() {}
   virtual ~MockExtensionService() {}
 
-  virtual const extensions::ExtensionSet* extensions() const OVERRIDE {
+  virtual const extensions::ExtensionSet* extensions() const override {
     return &extensions_;
   }
 
-  virtual void AddExtension(const extensions::Extension* extension) OVERRIDE {
+  virtual void AddExtension(const extensions::Extension* extension) override {
     extensions_.Insert(make_scoped_refptr(extension));
   }
 
   virtual const extensions::Extension* GetInstalledExtension(
-      const std::string& extension_id) const OVERRIDE {
+      const std::string& extension_id) const override {
     return extensions_.GetByID(extension_id);
   }
 
   virtual bool IsExtensionEnabled(
-      const std::string& extension_id) const OVERRIDE {
+      const std::string& extension_id) const override {
     return extensions_.Contains(extension_id) &&
         !disabled_extensions_.Contains(extension_id);
   }
 
   void UninstallExtension(const std::string& extension_id) {
     extensions_.Remove(extension_id);
     disabled_extensions_.Remove(extension_id);
   }
 
   void DisableExtension(const std::string& extension_id) {
     if (!IsExtensionEnabled(extension_id))
       return;
     const extensions::Extension* extension = extensions_.GetByID(extension_id);
     disabled_extensions_.Insert(make_scoped_refptr(extension));
   }
 
  private:
   extensions::ExtensionSet extensions_;
   extensions::ExtensionSet disabled_extensions_;
 
   DISALLOW_COPY_AND_ASSIGN(MockExtensionService);
 };
 
 class SyncWorkerTest : public testing::Test,
                        public base::SupportsWeakPtr<SyncWorkerTest> {
  public:
   SyncWorkerTest() {}
   virtual ~SyncWorkerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
 
     extension_service_.reset(new MockExtensionService);
     scoped_ptr<drive::DriveServiceInterface>
         fake_drive_service(new drive::FakeDriveService);
 
     scoped_ptr<SyncEngineContext>
         sync_engine_context(new SyncEngineContext(
             fake_drive_service.Pass(),
             nullptr /* drive_uploader */,
             nullptr /* task_logger */,
             base::ThreadTaskRunnerHandle::Get() /* ui_task_runner */,
             base::ThreadTaskRunnerHandle::Get() /* worker_task_runner */));
 
     sync_worker_.reset(new SyncWorker(
         profile_dir_.path(),
         extension_service_->AsWeakPtr(),
         in_memory_env_.get()));
     sync_worker_->Initialize(sync_engine_context.Pass());
 
     sync_worker_->SetSyncEnabled(true);
     base::RunLoop().RunUntilIdle();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     sync_worker_.reset();
     extension_service_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   MockExtensionService* extension_service() { return extension_service_.get(); }
   SyncWorker* sync_worker() { return sync_worker_.get(); }
 
   void UpdateRegisteredApps() {
     sync_worker_->UpdateRegisteredApps();
@@ skipping 237 matching lines @@
       base::Bind(&SyncWorkerTest::CheckServiceState,
                  AsWeakPtr(),
                  SYNC_STATUS_OK,
                  REMOTE_SERVICE_OK));
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system