Linux/ChromeOS Chromium style checker cleanup, chrome/browser edition.

chrome/browser/importer/firefox_importer_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 123 matching lines @@
   virtual void ImportItemStarted(importer::ImportItem item) OVERRIDE {}
   virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE {}
   virtual void ImportEnded() OVERRIDE {
     MessageLoop::current()->Quit();
     EXPECT_EQ(arraysize(kFirefox2Bookmarks), bookmark_count_);
     EXPECT_EQ(1U, history_count_);
     EXPECT_EQ(arraysize(kFirefox2Passwords), password_count_);
     EXPECT_EQ(arraysize(kFirefox2Keywords), keyword_count_);
   }
 
-  virtual bool BookmarkModelIsLoaded() const {
+  virtual bool BookmarkModelIsLoaded() const OVERRIDE {
     // Profile is ready for writing.
     return true;
   }
 
-  virtual bool TemplateURLServiceIsLoaded() const {
+  virtual bool TemplateURLServiceIsLoaded() const OVERRIDE {
     return true;
   }
 
-  virtual void AddPasswordForm(const content::PasswordForm& form) {
+  virtual void AddPasswordForm(const content::PasswordForm& form) OVERRIDE {
     PasswordInfo p = kFirefox2Passwords[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(WideToUTF16(p.username_element), form.username_element);
     EXPECT_EQ(WideToUTF16(p.username), form.username_value);
     EXPECT_EQ(WideToUTF16(p.password_element), form.password_element);
     EXPECT_EQ(WideToUTF16(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) {
+                              history::VisitSource visit_source) OVERRIDE {
     ASSERT_EQ(1U, page.size());
     EXPECT_EQ("http://en-us.www.mozilla.com/", page[0].url().spec());
     EXPECT_EQ(ASCIIToUTF16("Firefox Updated"), page[0].title());
     EXPECT_EQ(history::SOURCE_FIREFOX_IMPORTED, visit_source);
     ++history_count_;
   }
 
   virtual void AddBookmarks(const std::vector<BookmarkEntry>& bookmarks,
                             const string16& top_level_folder_name) OVERRIDE {
     for (size_t i = 0; i < bookmarks.size(); ++i) {
       if (FindBookmarkEntry(bookmarks[i], kFirefox2Bookmarks,
                             arraysize(kFirefox2Bookmarks)))
         ++bookmark_count_;
     }
   }
 
   virtual void AddKeywords(ScopedVector<TemplateURL> template_urls,
-                           bool unique_on_host_and_path) {
+                           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;
       string16 keyword = template_urls[i]->keyword();
       for (size_t j = 0; j < arraysize(kFirefox2Keywords); ++j) {
         if (template_urls[i]->keyword() ==
             WideToUTF16Hack(kFirefox2Keywords[j].keyword)) {
           EXPECT_EQ(kFirefox2Keywords[j].url, template_urls[i]->url());
           found = true;
           break;
         }
       }
       EXPECT_TRUE(found);
       ++keyword_count_;
     }
   }
 
-  void AddFavicons(const std::vector<history::ImportedFaviconUsage>& favicons) {
+  virtual void AddFavicons(
+      const std::vector<history::ImportedFaviconUsage>& favicons) OVERRIDE {
   }
 
  private:
-  ~FirefoxObserver() {}
+  virtual ~FirefoxObserver() {}
 
   size_t bookmark_count_;
   size_t history_count_;
   size_t password_count_;
   size_t keyword_count_;
 };
 
 const BookmarkInfo kFirefox3Bookmarks[] = {
   {true, 1, {L"Bookmarks Toolbar"},
     L"Toolbar",
@@ skipping 60 matching lines @@
   virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE {}
   virtual void ImportEnded() OVERRIDE {
     MessageLoop::current()->Quit();
     EXPECT_EQ(arraysize(kFirefox3Bookmarks), bookmark_count_);
     EXPECT_EQ(1U, history_count_);
     EXPECT_EQ(arraysize(kFirefox3Passwords), password_count_);
     if (import_search_engines_)
       EXPECT_EQ(arraysize(kFirefox3Keywords), keyword_count_);
   }
 
-  virtual bool BookmarkModelIsLoaded() const {
+  virtual bool BookmarkModelIsLoaded() const OVERRIDE {
     // Profile is ready for writing.
     return true;
   }
 
-  virtual bool TemplateURLServiceIsLoaded() const {
+  virtual bool TemplateURLServiceIsLoaded() const OVERRIDE {
     return true;
   }
 
-  virtual void AddPasswordForm(const content::PasswordForm& form) {
+  virtual void AddPasswordForm(const content::PasswordForm& form) OVERRIDE {
     PasswordInfo p = kFirefox3Passwords[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(WideToUTF16(p.username_element), form.username_element);
     EXPECT_EQ(WideToUTF16(p.username), form.username_value);
     EXPECT_EQ(WideToUTF16(p.password_element), form.password_element);
     EXPECT_EQ(WideToUTF16(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) {
+                              history::VisitSource visit_source) OVERRIDE {
     ASSERT_EQ(3U, page.size());
     EXPECT_EQ("http://www.google.com/", page[0].url().spec());
     EXPECT_EQ(ASCIIToUTF16("Google"), page[0].title());
     EXPECT_EQ("http://www.google.com/", page[1].url().spec());
     EXPECT_EQ(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(ASCIIToUTF16("example form (POST)"), page[2].title());
     EXPECT_EQ(history::SOURCE_FIREFOX_IMPORTED, visit_source);
     ++history_count_;
   }
 
   virtual void AddBookmarks(const std::vector<BookmarkEntry>& bookmarks,
                             const string16& top_level_folder_name) OVERRIDE {
     for (size_t i = 0; i < bookmarks.size(); ++i) {
       if (FindBookmarkEntry(bookmarks[i], kFirefox3Bookmarks,
                             arraysize(kFirefox3Bookmarks)))
         ++bookmark_count_;
     }
   }
 
-  void AddKeywords(ScopedVector<TemplateURL> template_urls,
-                   bool unique_on_host_and_path) {
+  virtual void AddKeywords(ScopedVector<TemplateURL> template_urls,
+                           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;
       string16 keyword = template_urls[i]->keyword();
       for (size_t j = 0; j < arraysize(kFirefox3Keywords); ++j) {
         if (template_urls[i]->keyword() ==
             WideToUTF16Hack(kFirefox3Keywords[j].keyword)) {
           EXPECT_EQ(kFirefox3Keywords[j].url, template_urls[i]->url());
           found = true;
           break;
         }
       }
       EXPECT_TRUE(found);
       ++keyword_count_;
     }
   }
 
-  void AddFavicons(const std::vector<history::ImportedFaviconUsage>& favicons) {
+  virtual void AddFavicons(
+      const std::vector<history::ImportedFaviconUsage>& favicons) OVERRIDE {
   }
 
  private:
-  ~Firefox3Observer() {}
+  virtual ~Firefox3Observer() {}
 
   size_t bookmark_count_;
   size_t history_count_;
   size_t password_count_;
   size_t keyword_count_;
   bool import_search_engines_;
 };
 
 }  // namespace
 
@@ skipping 386 matching lines @@
     EXPECT_EQ("http://www.tamurayukari.com/", entry.url.spec());
     EXPECT_EQ(0U, entry.path.size());
     entry = *it++;
     EXPECT_EQ(ASCIIToUTF16("Google"), entry.title);
     EXPECT_EQ("http://www.google.com/", entry.url.spec());
     EXPECT_EQ(0U, entry.path.size());
   }
 
   importer->Release();
 }