replace OVERRIDE and FINAL with override and final in chrome/browser/[a-i]*

chrome/browser/browsing_data/browsing_data_remover_unittest.cc

 // Copyright (c) 2012 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/browsing_data/browsing_data_remover.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 118 matching lines @@
   StoragePartitionRemovalData() : remove_mask(0),
                                   quota_storage_remove_mask(0) {}
 };
 
 class TestStoragePartition : public StoragePartition {
  public:
   TestStoragePartition() {}
   virtual ~TestStoragePartition() {}
 
   // content::StoragePartition implementation.
-  virtual base::FilePath GetPath() OVERRIDE { return base::FilePath(); }
-  virtual net::URLRequestContextGetter* GetURLRequestContext() OVERRIDE {
+  virtual base::FilePath GetPath() override { return base::FilePath(); }
+  virtual net::URLRequestContextGetter* GetURLRequestContext() override {
     return NULL;
   }
-  virtual net::URLRequestContextGetter* GetMediaURLRequestContext() OVERRIDE {
+  virtual net::URLRequestContextGetter* GetMediaURLRequestContext() override {
     return NULL;
   }
-  virtual storage::QuotaManager* GetQuotaManager() OVERRIDE { return NULL; }
-  virtual content::AppCacheService* GetAppCacheService() OVERRIDE {
+  virtual storage::QuotaManager* GetQuotaManager() override { return NULL; }
+  virtual content::AppCacheService* GetAppCacheService() override {
     return NULL;
   }
-  virtual storage::FileSystemContext* GetFileSystemContext() OVERRIDE {
+  virtual storage::FileSystemContext* GetFileSystemContext() override {
     return NULL;
   }
-  virtual storage::DatabaseTracker* GetDatabaseTracker() OVERRIDE {
+  virtual storage::DatabaseTracker* GetDatabaseTracker() override {
     return NULL;
   }
-  virtual content::DOMStorageContext* GetDOMStorageContext() OVERRIDE {
+  virtual content::DOMStorageContext* GetDOMStorageContext() override {
     return NULL;
   }
-  virtual content::IndexedDBContext* GetIndexedDBContext() OVERRIDE {
+  virtual content::IndexedDBContext* GetIndexedDBContext() override {
     return NULL;
   }
-  virtual content::ServiceWorkerContext* GetServiceWorkerContext() OVERRIDE {
+  virtual content::ServiceWorkerContext* GetServiceWorkerContext() override {
     return NULL;
   }
 
   virtual void ClearDataForOrigin(uint32 remove_mask,
                                   uint32 quota_storage_remove_mask,
                                   const GURL& storage_origin,
                                   net::URLRequestContextGetter* rq_context,
-                                  const base::Closure& callback) OVERRIDE {
+                                  const base::Closure& callback) override {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&TestStoragePartition::AsyncRunCallback,
                                        base::Unretained(this),
                                        callback));
   }
 
   virtual void ClearData(uint32 remove_mask,
                          uint32 quota_storage_remove_mask,
                          const GURL& storage_origin,
                          const OriginMatcherFunction& origin_matcher,
                          const base::Time begin,
                          const base::Time end,
-                         const base::Closure& callback) OVERRIDE {
+                         const base::Closure& callback) override {
     // Store stuff to verify parameters' correctness later.
     storage_partition_removal_data_.remove_mask = remove_mask;
     storage_partition_removal_data_.quota_storage_remove_mask =
         quota_storage_remove_mask;
     storage_partition_removal_data_.remove_origin = storage_origin;
     storage_partition_removal_data_.remove_begin = begin;
     storage_partition_removal_data_.remove_end = end;
     storage_partition_removal_data_.origin_matcher = origin_matcher;
 
     BrowserThread::PostTask(
@@ skipping 159 matching lines @@
 
   net::ChannelIDStore* GetChannelIDStore() {
     return channel_id_service_->GetChannelIDStore();
   }
 
   int ssl_config_changed_count() const {
     return ssl_config_changed_count_;
   }
 
   // net::SSLConfigService::Observer implementation:
-  virtual void OnSSLConfigChanged() OVERRIDE {
+  virtual void OnSSLConfigChanged() override {
     ssl_config_changed_count_++;
   }
 
  private:
   static void GetAllChannelIDsCallback(
       net::ChannelIDStore::ChannelIDList* dest,
       const net::ChannelIDStore::ChannelIDList& result) {
     *dest = result;
   }
 
@@ skipping 130 matching lines @@
 
     card.set_guid(base::GenerateGUID());
     card.set_origin(kChromeOrigin);
     cards.push_back(card);
 
     personal_data_manager_->SetCreditCards(&cards);
     base::MessageLoop::current()->Run();
   }
 
  private:
-  virtual void OnPersonalDataChanged() OVERRIDE {
+  virtual void OnPersonalDataChanged() override {
     base::MessageLoop::current()->Quit();
   }
 
   autofill::PersonalDataManager* personal_data_manager_;
   DISALLOW_COPY_AND_ASSIGN(RemoveAutofillTester);
 };
 
 class RemoveLocalStorageTester {
  public:
   explicit RemoveLocalStorageTester(TestingProfile* profile)
@@ skipping 68 matching lines @@
 };
 
 class MockDomainReliabilityService : public DomainReliabilityService {
  public:
   MockDomainReliabilityService() : clear_count_(0) {}
 
   virtual ~MockDomainReliabilityService() {}
 
   virtual scoped_ptr<DomainReliabilityMonitor> CreateMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
-      OVERRIDE {
+      override {
     NOTREACHED();
     return scoped_ptr<DomainReliabilityMonitor>();
   }
 
   virtual void ClearBrowsingData(DomainReliabilityClearMode clear_mode,
-                                 const base::Closure& callback) OVERRIDE {
+                                 const base::Closure& callback) override {
     clear_count_++;
     last_clear_mode_ = clear_mode;
     callback.Run();
   }
 
   virtual void GetWebUIData(
       const base::Callback<void(scoped_ptr<base::Value>)>& callback)
-      const OVERRIDE {
+      const override {
     NOTREACHED();
   }
 
   int clear_count() const { return clear_count_; }
 
   DomainReliabilityClearMode last_clear_mode() const {
     return last_clear_mode_;
   }
 
  private:
@@ skipping 167 matching lines @@
     return called_with_details_->origin_set_mask;
   }
 
   StoragePartitionRemovalData GetStoragePartitionRemovalData() {
     return storage_partition_removal_data_;
   }
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     DCHECK_EQ(type, chrome::NOTIFICATION_BROWSING_DATA_REMOVED);
 
     // We're not taking ownership of the details object, but storing a copy of
     // it locally.
     called_with_details_.reset(new BrowsingDataRemover::NotificationDetails(
         *content::Details<BrowsingDataRemover::NotificationDetails>(
             details).ptr()));
 
     registrar_.RemoveAll();
   }
@@ skipping 1012 matching lines @@
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_NoMonitor) {
   BlockUntilBrowsingDataRemoved(
       BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_HISTORY |
       BrowsingDataRemover::REMOVE_COOKIES, false);
 }