Update {virtual,override} to follow C++11 style in chrome.

chrome/browser/importer/ie_importer_browsertest_win.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.
 
 // The order of these includes is important.
 #include <windows.h>
 #include <unknwn.h>
 #include <intshcut.h>
 #include <propvarutil.h>
 #include <shlguid.h>
@@ skipping 218 matching lines @@
         history_count_(0),
         password_count_(0),
         favicon_count_(0),
         homepage_count_(0),
         ie7_password_count_(0),
         importer_items_(importer_items),
         ie_version_(ie_version) {
   }
 
   // importer::ImporterProgressObserver:
-  virtual void ImportStarted() override {}
-  virtual void ImportItemStarted(importer::ImportItem item) override {}
-  virtual void ImportItemEnded(importer::ImportItem item) override {}
-  virtual void ImportEnded() override {
+  void ImportStarted() override {}
+  void ImportItemStarted(importer::ImportItem item) override {}
+  void ImportItemEnded(importer::ImportItem item) override {}
+  void ImportEnded() override {
     base::MessageLoop::current()->Quit();
     if (importer_items_ & importer::FAVORITES) {
       EXPECT_EQ(arraysize(kIEBookmarks), bookmark_count_);
       EXPECT_EQ(arraysize(kIEFaviconGroup), favicon_count_);
     }
     if (importer_items_ & importer::HISTORY)
       EXPECT_EQ(2, history_count_);
     if (importer_items_ & importer::HOME_PAGE)
       EXPECT_EQ(1, homepage_count_);
     if ((importer_items_ & importer::PASSWORDS) && (ie_version_ == IE7))
       EXPECT_EQ(1, ie7_password_count_);
     // We need to test the IE6 password importer code.
     // https://crbug.com/257100
     // EXPECT_EQ(1, password_count_);
   }
 
-  virtual bool BookmarkModelIsLoaded() const {
+  // ProfileWriter:
+  bool BookmarkModelIsLoaded() const override {
     // Profile is ready for writing.
     return true;
   }
 
-  virtual bool TemplateURLServiceIsLoaded() const {
+  bool TemplateURLServiceIsLoaded() const override {
     return true;
   }
 
-  virtual void AddPasswordForm(const autofill::PasswordForm& form) {
+  void AddPasswordForm(const autofill::PasswordForm& form) override {
     // Importer should obtain this password form only.
     EXPECT_EQ(GURL("http://localhost:8080/security/index.htm"), form.origin);
     EXPECT_EQ("http://localhost:8080/", form.signon_realm);
     EXPECT_EQ(L"user", form.username_element);
     EXPECT_EQ(L"1", form.username_value);
     EXPECT_EQ(L"", form.password_element);
     EXPECT_EQ(L"2", form.password_value);
     EXPECT_EQ("", form.action.spec());
     ++password_count_;
   }
 
-  virtual void AddHistoryPage(const history::URLRows& page,
-                              history::VisitSource visit_source) {
+  void AddHistoryPage(const history::URLRows& page,
+                      history::VisitSource visit_source) override {
     bool cache_item_found = false;
     bool history_item_found = false;
     // Importer should read the specified URL.
     for (size_t i = 0; i < page.size(); ++i) {
       if (page[i].title() == kIEIdentifyTitle &&
           page[i].url() == GURL(kIEIdentifyUrl)) {
         EXPECT_FALSE(page[i].hidden());
         history_item_found = true;
         ++history_count_;
       }
       if (page[i].title() == kIECacheItemTitle &&
           page[i].url() == GURL(kIECacheItemUrl)) {
         EXPECT_TRUE(page[i].hidden());
         cache_item_found = true;
         ++history_count_;
       }
     }
     EXPECT_TRUE(history_item_found);
     EXPECT_TRUE(cache_item_found);
     EXPECT_EQ(history::SOURCE_IE_IMPORTED, visit_source);
   }
 
-  virtual void AddBookmarks(
-      const std::vector<ImportedBookmarkEntry>& bookmarks,
-      const base::string16& top_level_folder_name) override {
+  void AddBookmarks(const std::vector<ImportedBookmarkEntry>& bookmarks,
+                    const base::string16& top_level_folder_name) override {
     ASSERT_LE(bookmark_count_ + bookmarks.size(), arraysize(kIEBookmarks));
     // Importer should import the IE Favorites folder 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],
                                  kIEBookmarks[bookmark_count_])) << i;
       ++bookmark_count_;
     }
   }
 
   virtual void AddKeyword(std::vector<TemplateURL*> template_url,
                           int default_keyword_index) {
     // TODO(jcampan): bug 1169230: we should test keyword importing for IE.
     // In order to do that we'll probably need to mock the Windows registry.
     NOTREACHED();
     STLDeleteContainerPointers(template_url.begin(), template_url.end());
   }
 
-  virtual void AddFavicons(
-      const favicon_base::FaviconUsageDataList& usage) override {
+  void AddFavicons(const favicon_base::FaviconUsageDataList& usage) override {
     // Importer should group the favicon information for each favicon URL.
     for (size_t i = 0; i < arraysize(kIEFaviconGroup); ++i) {
       GURL favicon_url(kIEFaviconGroup[i].favicon_url);
       std::set<GURL> urls;
       for (size_t j = 0; j < arraysize(kIEFaviconGroup[i].site_url); ++j)
         urls.insert(GURL(kIEFaviconGroup[i].site_url[j]));
 
       SCOPED_TRACE(testing::Message() << "Expected Favicon: " << favicon_url);
 
       bool expected_favicon_url_found = false;
@@ skipping 40 matching lines @@
 
 class MalformedFavoritesRegistryTestObserver
     : public ProfileWriter,
       public importer::ImporterProgressObserver {
  public:
   MalformedFavoritesRegistryTestObserver() : ProfileWriter(NULL) {
     bookmark_count_ = 0;
   }
 
   // importer::ImporterProgressObserver:
-  virtual void ImportStarted() override {}
-  virtual void ImportItemStarted(importer::ImportItem item) override {}
-  virtual void ImportItemEnded(importer::ImportItem item) override {}
-  virtual void ImportEnded() override {
+  void ImportStarted() override {}
+  void ImportItemStarted(importer::ImportItem item) override {}
+  void ImportItemEnded(importer::ImportItem item) override {}
+  void ImportEnded() override {
     base::MessageLoop::current()->Quit();
     EXPECT_EQ(arraysize(kIESortedBookmarks), bookmark_count_);
   }
 
-  virtual bool BookmarkModelIsLoaded() const { return true; }
-  virtual bool TemplateURLServiceIsLoaded() const { return true; }
+  // ProfileWriter:
+  bool BookmarkModelIsLoaded() const override { return true; }
+  bool TemplateURLServiceIsLoaded() const override { return true; }
 
-  virtual void AddPasswordForm(const autofill::PasswordForm& form) {}
-  virtual void AddHistoryPage(const history::URLRows& page,
-                              history::VisitSource visit_source) {}
-  virtual void AddKeyword(std::vector<TemplateURL*> template_url,
-                          int default_keyword_index) {}
-  virtual void AddBookmarks(
-      const std::vector<ImportedBookmarkEntry>& bookmarks,
-      const base::string16& top_level_folder_name) override {
+  void AddPasswordForm(const autofill::PasswordForm& form) override {}
+  void AddHistoryPage(const history::URLRows& page,
+                      history::VisitSource visit_source) override {}
+  void AddKeywords(ScopedVector<TemplateURL> template_urls,
+                   bool unique_on_host_and_path) override {}
+  void AddBookmarks(const std::vector<ImportedBookmarkEntry>& bookmarks,
+                    const base::string16& top_level_folder_name) override {
     ASSERT_LE(bookmark_count_ + bookmarks.size(),
               arraysize(kIESortedBookmarks));
     for (size_t i = 0; i < bookmarks.size(); ++i) {
       EXPECT_NO_FATAL_FAILURE(
           TestEqualBookmarkEntry(bookmarks[i],
                                  kIESortedBookmarks[bookmark_count_])) << i;
       ++bookmark_count_;
     }
   }
 
  private:
-  ~MalformedFavoritesRegistryTestObserver() {}
+  ~MalformedFavoritesRegistryTestObserver() override {}
 
   size_t bookmark_count_;
 };
 
 }  // 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.
 class IEImporterBrowserTest : public InProcessBrowserTest {
  protected:
-  virtual void SetUp() override {
+  void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     // This will launch the browser test and thus needs to happen last.
     InProcessBrowserTest::SetUp();
   }
 
   base::ScopedTempDir temp_dir_;
 
   // Overrides the default registry key for IE registry keys like favorites,
   // settings, password store, etc.
@@ skipping 207 matching lines @@
   source_profile.source_path = temp_dir_.path();
 
   host->StartImportSettings(
       source_profile,
       browser()->profile(),
       importer::HOME_PAGE,
       observer);
   base::MessageLoop::current()->Run();
 }