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

chrome/browser/download/save_page_browsertest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 67 matching lines @@
   bool WaitForPersisted() {
     if (persisted_)
       return true;
     waiting_ = true;
     content::RunMessageLoop();
     waiting_ = false;
     return persisted_;
   }
 
   virtual void OnDownloadStored(DownloadItem* item,
-                                const history::DownloadRow& info) OVERRIDE {
+                                const history::DownloadRow& info) override {
     persisted_ = persisted_ || filter_.Run(item, info);
     if (persisted_ && waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
  private:
   Profile* profile_;
   PersistedFilter filter_;
   bool waiting_;
   bool persisted_;
@@ skipping 15 matching lines @@
   bool WaitForRemoved() {
     if (removed_)
       return true;
     waiting_ = true;
     content::RunMessageLoop();
     waiting_ = false;
     return removed_;
   }
 
   virtual void OnDownloadStored(DownloadItem* item,
-                                const history::DownloadRow& info) OVERRIDE {
+                                const history::DownloadRow& info) override {
   }
 
-  virtual void OnDownloadsRemoved(const DownloadHistory::IdSet& ids) OVERRIDE {
+  virtual void OnDownloadsRemoved(const DownloadHistory::IdSet& ids) override {
     removed_ = ids.find(download_id_) != ids.end();
     if (removed_ && waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
  private:
   bool removed_;
   bool waiting_;
   int32 download_id_;
 
@@ skipping 73 matching lines @@
       waiting_ = false;
     }
 
     *items_seen = items_seen_;
     return;
   }
 
  private:
   // DownloadManager::Observer
   virtual void OnDownloadCreated(
-      DownloadManager* manager, DownloadItem* item) OVERRIDE {
+      DownloadManager* manager, DownloadItem* item) override {
     DCHECK_EQ(manager, manager_);
     items_seen_.push_back(item);
 
     if (waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
-  virtual void ManagerGoingDown(DownloadManager* manager) OVERRIDE {
+  virtual void ManagerGoingDown(DownloadManager* manager) override {
     manager_->RemoveObserver(this);
     manager_ = NULL;
     if (waiting_)
       base::MessageLoopForUI::current()->Quit();
   }
 
   bool waiting_;
   DownloadManager* manager_;
   std::vector<DownloadItem*> items_seen_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemCreatedObserver);
 };
 
 class SavePackageFinishedObserver : public content::DownloadManager::Observer {
  public:
   SavePackageFinishedObserver(content::DownloadManager* manager,
                               const base::Closure& callback)
       : download_manager_(manager),
         callback_(callback) {
     download_manager_->AddObserver(this);
   }
 
   virtual ~SavePackageFinishedObserver() {
     if (download_manager_)
       download_manager_->RemoveObserver(this);
   }
 
   // DownloadManager::Observer:
   virtual void OnSavePackageSuccessfullyFinished(
-      content::DownloadManager* manager, content::DownloadItem* item) OVERRIDE {
+      content::DownloadManager* manager, content::DownloadItem* item) override {
     callback_.Run();
   }
-  virtual void ManagerGoingDown(content::DownloadManager* manager) OVERRIDE {
+  virtual void ManagerGoingDown(content::DownloadManager* manager) override {
     download_manager_->RemoveObserver(this);
     download_manager_ = NULL;
   }
 
  private:
   content::DownloadManager* download_manager_;
   base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SavePackageFinishedObserver);
 };
 
 class SavePageBrowserTest : public InProcessBrowserTest {
  public:
   SavePageBrowserTest() {}
   virtual ~SavePageBrowserTest();
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir_));
     ASSERT_TRUE(save_dir_.CreateUniqueTempDir());
     InProcessBrowserTest::SetUp();
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     browser()->profile()->GetPrefs()->SetFilePath(
         prefs::kDownloadDefaultDirectory, save_dir_.path());
     browser()->profile()->GetPrefs()->SetFilePath(
         prefs::kSaveFileDefaultDirectory, save_dir_.path());
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
   }
 
   GURL NavigateToMockURL(const std::string& prefix) {
@@ skipping 143 matching lines @@
 
 class DelayingDownloadManagerDelegate : public ChromeDownloadManagerDelegate {
  public:
   explicit DelayingDownloadManagerDelegate(Profile* profile)
     : ChromeDownloadManagerDelegate(profile) {
   }
   virtual ~DelayingDownloadManagerDelegate() {}
 
   virtual bool ShouldCompleteDownload(
       content::DownloadItem* item,
-      const base::Closure& user_complete_callback) OVERRIDE {
+      const base::Closure& user_complete_callback) override {
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DelayingDownloadManagerDelegate);
 };
 
 // Disabled on Windows due to flakiness. http://crbug.com/162323
 #if defined(OS_WIN)
 #define MAYBE_SaveHTMLOnlyTabDestroy DISABLED_SaveHTMLOnlyTabDestroy
@@ skipping 283 matching lines @@
 
   EXPECT_TRUE(base::DieFileDie(full_file_name, false));
   EXPECT_TRUE(base::DieFileDie(dir, true));
 }
 #endif
 
 class SavePageAsMHTMLBrowserTest : public SavePageBrowserTest {
  public:
   SavePageAsMHTMLBrowserTest() {}
   virtual ~SavePageAsMHTMLBrowserTest();
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kSavePageAsMHTML);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SavePageAsMHTMLBrowserTest);
 };
 
 SavePageAsMHTMLBrowserTest::~SavePageAsMHTMLBrowserTest() {
 }
 
@@ skipping 38 matching lines @@
   base::FilePath download_dir = DownloadPrefs::FromDownloadManager(
       GetDownloadManager())->DownloadPath();
   base::FilePath filename = download_dir.AppendASCII("dataurl.txt");
   ASSERT_TRUE(base::PathExists(filename));
   std::string contents;
   EXPECT_TRUE(base::ReadFileToString(filename, &contents));
   EXPECT_EQ("foo", contents);
 }
 
 }  // namespace