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

chrome/browser/safe_browsing/safe_browsing_service_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.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include <algorithm>
 
@@ skipping 52 matching lines @@
 }  // namespace
 
 // A SafeBrowingDatabase class that allows us to inject the malicious URLs.
 class TestSafeBrowsingDatabase :  public SafeBrowsingDatabase {
  public:
   TestSafeBrowsingDatabase() {}
 
   virtual ~TestSafeBrowsingDatabase() {}
 
   // Initializes the database with the given filename.
-  virtual void Init(const FilePath& filename) {}
+  virtual void Init(const FilePath& filename) OVERRIDE {}
 
   // Deletes the current database and creates a new one.
-  virtual bool ResetDatabase() {
+  virtual bool ResetDatabase() OVERRIDE {
     badurls_.clear();
     return true;
   }
 
   // Called on the IO thread to check if the given URL is safe or not.  If we
   // can synchronously determine that the URL is safe, CheckUrl returns true,
   // otherwise it returns false.
   virtual bool ContainsBrowseUrl(const GURL& url,
                                  std::string* matching_list,
                                  std::vector<SBPrefix>* prefix_hits,
                                  std::vector<SBFullHashResult>* full_hits,
-                                 base::Time last_update) {
+                                 base::Time last_update) OVERRIDE {
     std::vector<GURL> urls(1, url);
     return ContainsUrl(safe_browsing_util::kMalwareList,
                        safe_browsing_util::kPhishingList,
                        urls, prefix_hits, full_hits);
   }
-  virtual bool ContainsDownloadUrl(const std::vector<GURL>& urls,
-                                   std::vector<SBPrefix>* prefix_hits) {
+  virtual bool ContainsDownloadUrl(
+      const std::vector<GURL>& urls,
+      std::vector<SBPrefix>* prefix_hits) OVERRIDE {
     std::vector<SBFullHashResult> full_hits;
     bool found = ContainsUrl(safe_browsing_util::kBinUrlList,
                              safe_browsing_util::kBinHashList,
                              urls, prefix_hits, &full_hits);
     if (!found)
       return false;
     DCHECK_LE(1U, prefix_hits->size());
     return true;
   }
-  virtual bool ContainsDownloadHashPrefix(const SBPrefix& prefix) {
+  virtual bool ContainsDownloadHashPrefix(const SBPrefix& prefix) OVERRIDE {
     return download_digest_prefix_.count(prefix) > 0;
   }
-  virtual bool ContainsCsdWhitelistedUrl(const GURL& url) {
+  virtual bool ContainsCsdWhitelistedUrl(const GURL& url) OVERRIDE {
     return true;
   }
-  virtual bool ContainsDownloadWhitelistedString(const std::string& str) {
+  virtual bool ContainsDownloadWhitelistedString(
+      const std::string& str) OVERRIDE {
     return true;
   }
-  virtual bool ContainsDownloadWhitelistedUrl(const GURL& url) {
+  virtual bool ContainsDownloadWhitelistedUrl(const GURL& url) OVERRIDE {
     return true;
   }
   virtual bool ContainsExtensionPrefixes(
       const std::vector<SBPrefix>& prefixes,
       std::vector<SBPrefix>* prefix_hits) OVERRIDE {
     return true;
   }
-  virtual bool UpdateStarted(std::vector<SBListChunkRanges>* lists) {
+  virtual bool UpdateStarted(std::vector<SBListChunkRanges>* lists) OVERRIDE {
     ADD_FAILURE() << "Not implemented.";
     return false;
   }
   virtual void InsertChunks(const std::string& list_name,
-                            const SBChunkList& chunks) {
+                            const SBChunkList& chunks) OVERRIDE {
     ADD_FAILURE() << "Not implemented.";
   }
-  virtual void DeleteChunks(const std::vector<SBChunkDelete>& chunk_deletes) {
+  virtual void DeleteChunks(
+      const std::vector<SBChunkDelete>& chunk_deletes) OVERRIDE {
     ADD_FAILURE() << "Not implemented.";
   }
-  virtual void UpdateFinished(bool update_succeeded) {
+  virtual void UpdateFinished(bool update_succeeded) OVERRIDE {
     ADD_FAILURE() << "Not implemented.";
   }
   virtual void CacheHashResults(const std::vector<SBPrefix>& prefixes,
-      const std::vector<SBFullHashResult>& full_hits) {
+      const std::vector<SBFullHashResult>& full_hits) OVERRIDE {
     // Do nothing for the cache.
   }
 
   // Fill up the database with test URL.
   void AddUrl(const GURL& url,
               const std::string& list_name,
               const std::vector<SBPrefix>& prefix_hits,
               const std::vector<SBFullHashResult>& full_hits) {
     badurls_[url.spec()].list_name = list_name;
     badurls_[url.spec()].prefix_hits = prefix_hits;
@@ skipping 48 matching lines @@
 // Factory that creates TestSafeBrowsingDatabase instances.
 class TestSafeBrowsingDatabaseFactory : public SafeBrowsingDatabaseFactory {
  public:
   TestSafeBrowsingDatabaseFactory() : db_(NULL) {}
   virtual ~TestSafeBrowsingDatabaseFactory() {}
 
   virtual SafeBrowsingDatabase* CreateSafeBrowsingDatabase(
       bool enable_download_protection,
       bool enable_client_side_whitelist,
       bool enable_download_whitelist,
-      bool enable_extension_blacklist) {
+      bool enable_extension_blacklist) OVERRIDE {
     db_ = new TestSafeBrowsingDatabase();
     return db_;
   }
   TestSafeBrowsingDatabase* GetDb() {
     return db_;
   }
  private:
   // Owned by the SafebrowsingService.
   TestSafeBrowsingDatabase* db_;
 };
 
 // A TestProtocolManager that could return fixed responses from
 // safebrowsing server for testing purpose.
 class TestProtocolManager :  public SafeBrowsingProtocolManager {
  public:
   TestProtocolManager(SafeBrowsingProtocolManagerDelegate* delegate,
                       net::URLRequestContextGetter* request_context_getter,
                       const SafeBrowsingProtocolConfig& config)
       : SafeBrowsingProtocolManager(delegate, request_context_getter, config) {
     create_count_++;
   }
 
-  ~TestProtocolManager() {
+  virtual ~TestProtocolManager() {
     delete_count_++;
   }
 
   // This function is called when there is a prefix hit in local safebrowsing
   // database and safebrowsing service issues a get hash request to backends.
   // We return a result from the prefilled full_hashes_ hash_map to simulate
   // server's response. At the same time, latency is added to simulate real
   // life network issues.
   virtual void GetFullHash(
       const std::vector<SBPrefix>& prefixes,
@@ skipping 622 matching lines @@
 
   // End the test, shutting down the browser.
   // SafeBrowsingServiceShutdownTest::TearDown will check the create_count and
   // delete_count again.
 }
 
 class SafeBrowsingDatabaseManagerCookieTest : public InProcessBrowserTest {
  public:
   SafeBrowsingDatabaseManagerCookieTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) {
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // We need to start the test server to get the host&port in the url.
     ASSERT_TRUE(test_server()->Start());
 
     // Makes sure the auto update is not triggered. This test will force the
     // update when needed.
     command_line->AppendSwitch(switches::kSbDisableAutoUpdate);
 
     // Point to the testing server for all SafeBrowsing requests.
     GURL url_prefix = test_server()->GetURL(
         "expect-and-set-cookie?expect=a%3db"
         "&set=c%3dd%3b%20Expires=Fri,%2001%20Jan%202038%2001:01:01%20GMT"
         "&data=foo#");
     command_line->AppendSwitchASCII(switches::kSbURLPrefix, url_prefix.spec());
   }
 
-  virtual bool SetUpUserDataDirectory() {
+  virtual bool SetUpUserDataDirectory() OVERRIDE {
     FilePath cookie_path(SafeBrowsingService::GetCookieFilePathForTesting());
     EXPECT_FALSE(file_util::PathExists(cookie_path));
 
     FilePath test_dir;
     if (!PathService::Get(chrome::DIR_TEST_DATA, &test_dir)) {
       EXPECT_TRUE(false);
       return false;
     }
 
     // Initialize the SafeBrowsing cookies with a pre-created cookie store.  It
@@ skipping 24 matching lines @@
       return false;
     }
     if (!smt.Run()) {
       EXPECT_TRUE(false);
       return false;
     }
 
     return InProcessBrowserTest::SetUpUserDataDirectory();
   }
 
-  virtual void TearDownInProcessBrowserTestFixture() {
+  virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
     InProcessBrowserTest::TearDownInProcessBrowserTestFixture();
 
     sql::Connection db;
     FilePath cookie_path(SafeBrowsingService::GetCookieFilePathForTesting());
     ASSERT_TRUE(db.Open(cookie_path));
 
     sql::Statement smt(db.GetUniqueStatement(
         "SELECT name, value FROM cookies ORDER BY name"));
     ASSERT_TRUE(smt.is_valid());
 
     ASSERT_TRUE(smt.Step());
     ASSERT_EQ("a", smt.ColumnString(0));
     ASSERT_EQ("b", smt.ColumnString(1));
     ASSERT_TRUE(smt.Step());
     ASSERT_EQ("c", smt.ColumnString(0));
     ASSERT_EQ("d", smt.ColumnString(1));
     EXPECT_FALSE(smt.Step());
   }
 
-  virtual void SetUpOnMainThread() {
+  virtual void SetUpOnMainThread() OVERRIDE {
     sb_service_ = g_browser_process->safe_browsing_service();
     ASSERT_TRUE(sb_service_ != NULL);
   }
 
-  virtual void CleanUpOnMainThread() {
+  virtual void CleanUpOnMainThread() OVERRIDE {
     sb_service_ = NULL;
   }
 
   void ForceUpdate() {
     sb_service_->protocol_manager()->ForceScheduleNextUpdate(
         base::TimeDelta::FromSeconds(0));
   }
 
   scoped_refptr<SafeBrowsingService> sb_service_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDatabaseManagerCookieTest);
 };
 
 // Test that a Safe Browsing database update request both sends cookies and can
 // save cookies.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingDatabaseManagerCookieTest,
                        TestSBUpdateCookies) {
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
           sb_service_->database_manager()));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }