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

chrome/browser/importer/firefox_importer_browsertest.cc

 // Copyright (c) 2013 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/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
@@ skipping 109 matching lines @@
  public:
   explicit FirefoxObserver(bool use_keyword_in_json)
       : ProfileWriter(NULL),
         bookmark_count_(0),
         history_count_(0),
         password_count_(0),
         keyword_count_(0),
         use_keyword_in_json_(use_keyword_in_json) {}
 
   // importer::ImporterProgressObserver:
-  virtual void ImportStarted() OVERRIDE {}
-  virtual void ImportItemStarted(importer::ImportItem item) OVERRIDE {}
-  virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE {}
-  virtual void ImportEnded() OVERRIDE {
+  virtual void ImportStarted() override {}
+  virtual void ImportItemStarted(importer::ImportItem item) override {}
+  virtual void ImportItemEnded(importer::ImportItem item) override {}
+  virtual void ImportEnded() override {
     base::MessageLoop::current()->Quit();
     EXPECT_EQ(arraysize(kFirefoxBookmarks), bookmark_count_);
     EXPECT_EQ(1U, history_count_);
     EXPECT_EQ(arraysize(kFirefoxPasswords), password_count_);
     EXPECT_EQ(arraysize(kFirefoxKeywords), keyword_count_);
   }
 
-  virtual bool BookmarkModelIsLoaded() const OVERRIDE {
+  virtual bool BookmarkModelIsLoaded() const override {
     // Profile is ready for writing.
     return true;
   }
 
-  virtual bool TemplateURLServiceIsLoaded() const OVERRIDE {
+  virtual bool TemplateURLServiceIsLoaded() const override {
     return true;
   }
 
-  virtual void AddPasswordForm(const autofill::PasswordForm& form) OVERRIDE {
+  virtual void AddPasswordForm(const autofill::PasswordForm& form) override {
     PasswordInfo p = kFirefoxPasswords[password_count_];
     EXPECT_EQ(p.origin, form.origin.spec());
     EXPECT_EQ(p.realm, form.signon_realm);
     EXPECT_EQ(p.action, form.action.spec());
     EXPECT_EQ(base::ASCIIToUTF16(p.username_element), form.username_element);
     EXPECT_EQ(base::ASCIIToUTF16(p.username), form.username_value);
     EXPECT_EQ(base::ASCIIToUTF16(p.password_element), form.password_element);
     EXPECT_EQ(base::ASCIIToUTF16(p.password), form.password_value);
     EXPECT_EQ(p.blacklisted, form.blacklisted_by_user);
     ++password_count_;
   }
 
   virtual void AddHistoryPage(const history::URLRows& page,
-                              history::VisitSource visit_source) OVERRIDE {
+                              history::VisitSource visit_source) override {
     ASSERT_EQ(3U, page.size());
     EXPECT_EQ("http://www.google.com/", page[0].url().spec());
     EXPECT_EQ(base::ASCIIToUTF16("Google"), page[0].title());
     EXPECT_EQ("http://www.google.com/", page[1].url().spec());
     EXPECT_EQ(base::ASCIIToUTF16("Google"), page[1].title());
     EXPECT_EQ("http://www.cs.unc.edu/~jbs/resources/perl/perl-cgi/programs/"
               "form1-POST.html", page[2].url().spec());
     EXPECT_EQ(base::ASCIIToUTF16("example form (POST)"), page[2].title());
     EXPECT_EQ(history::SOURCE_FIREFOX_IMPORTED, visit_source);
     ++history_count_;
   }
 
   virtual void AddBookmarks(
       const std::vector<ImportedBookmarkEntry>& bookmarks,
-      const base::string16& top_level_folder_name) OVERRIDE {
+      const base::string16& top_level_folder_name) override {
     ASSERT_LE(bookmark_count_ + bookmarks.size(), arraysize(kFirefoxBookmarks));
     // Importer should import the FF favorites the same as the list, in the same
     // order.
     for (size_t i = 0; i < bookmarks.size(); ++i) {
       EXPECT_NO_FATAL_FAILURE(
           TestEqualBookmarkEntry(bookmarks[i],
                                  kFirefoxBookmarks[bookmark_count_])) << i;
       ++bookmark_count_;
     }
   }
 
   virtual void AddAutofillFormDataEntries(
-      const std::vector<autofill::AutofillEntry>& autofill_entries) OVERRIDE {
+      const std::vector<autofill::AutofillEntry>& autofill_entries) override {
     EXPECT_EQ(arraysize(kFirefoxAutofillEntries), autofill_entries.size());
     for (size_t i = 0; i < arraysize(kFirefoxAutofillEntries); ++i) {
       EXPECT_EQ(kFirefoxAutofillEntries[i].name,
                 base::UTF16ToUTF8(autofill_entries[i].key().name()));
       EXPECT_EQ(kFirefoxAutofillEntries[i].value,
                 base::UTF16ToUTF8(autofill_entries[i].key().value()));
     }
   }
 
   virtual void AddKeywords(ScopedVector<TemplateURL> template_urls,
-                           bool unique_on_host_and_path) OVERRIDE {
+                           bool unique_on_host_and_path) override {
     for (size_t i = 0; i < template_urls.size(); ++i) {
       // The order might not be deterministic, look in the expected list for
       // that template URL.
       bool found = false;
       const base::string16& imported_keyword = template_urls[i]->keyword();
       for (size_t j = 0; j < arraysize(kFirefoxKeywords); ++j) {
         const base::string16 expected_keyword = base::WideToUTF16(
             use_keyword_in_json_ ?
             kFirefoxKeywords[j].keyword_in_json :
             kFirefoxKeywords[j].keyword_in_sqlite);
         if (imported_keyword == expected_keyword) {
           EXPECT_EQ(kFirefoxKeywords[j].url, template_urls[i]->url());
           found = true;
           break;
         }
       }
       EXPECT_TRUE(found);
       ++keyword_count_;
     }
   }
 
   virtual void AddFavicons(
-      const std::vector<ImportedFaviconUsage>& favicons) OVERRIDE {
+      const std::vector<ImportedFaviconUsage>& favicons) override {
   }
 
  private:
   virtual ~FirefoxObserver() {}
 
   size_t bookmark_count_;
   size_t history_count_;
   size_t password_count_;
   size_t keyword_count_;
 
   // Newer versions of Firefox can store custom keyword names in json, which
   // override the sqlite values. To be able to test both older and newer
   // versions, tests set this variable to indicate whether to expect the
   // |keyword_in_sqlite| or |keyword_in_json| values from the reference data.
   bool use_keyword_in_json_;
 };
 
 }  // namespace
 
 // These tests need to be browser tests in order to be able to run the OOP
 // import (via ExternalProcessImporterHost) which launches a utility process on
 // supported platforms.
 class FirefoxProfileImporterBrowserTest : public InProcessBrowserTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Creates a new profile in a new subdirectory in the temp directory.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     base::FilePath test_path = temp_dir_.path().AppendASCII("ImporterTest");
     base::DeleteFile(test_path, true);
     base::CreateDirectory(test_path);
     profile_path_ = test_path.AppendASCII("profile");
     app_path_ = test_path.AppendASCII("app");
     base::CreateDirectory(app_path_);
 
     // This will launch the browser test and thus needs to happen last.
@@ skipping 68 matching lines @@
   scoped_refptr<FirefoxObserver> observer(new FirefoxObserver(false));
   FirefoxImporterBrowserTest(
       "firefox35_profile", observer.get(), observer.get());
 }
 
 IN_PROC_BROWSER_TEST_F(FirefoxProfileImporterBrowserTest,
                        MAYBE_IMPORTER(FirefoxImporter)) {
   scoped_refptr<FirefoxObserver> observer(new FirefoxObserver(true));
   FirefoxImporterBrowserTest("firefox_profile", observer.get(), observer.get());
 }