replace OVERRIDE and FINAL with override and final in chrome/browser/[r-z]*

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 53 matching lines @@
     SafeBrowsingProtocolManager::FullHashCallback callback,
     const std::vector<SBFullHashResult>& result) {
   callback.Run(result, base::TimeDelta::FromMinutes(45));
 }
 
 class FakeSafeBrowsingService : public SafeBrowsingService {
  public:
   explicit FakeSafeBrowsingService(const std::string& url_prefix)
       : url_prefix_(url_prefix) {}
 
-  virtual SafeBrowsingProtocolConfig GetProtocolConfig() const OVERRIDE {
+  virtual SafeBrowsingProtocolConfig GetProtocolConfig() const override {
     SafeBrowsingProtocolConfig config;
     config.url_prefix = url_prefix_;
     // Makes sure the auto update is not triggered. The tests will force the
     // update when needed.
     config.disable_auto_update = true;
 #if defined(OS_ANDROID)
     config.disable_connection_check = true;
 #endif
     config.client_name = "browser_tests";
     return config;
   }
 
  private:
   virtual ~FakeSafeBrowsingService() {}
 
   std::string url_prefix_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingService);
 };
 
 // Factory that creates FakeSafeBrowsingService instances.
 class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
  public:
   explicit TestSafeBrowsingServiceFactory(const std::string& url_prefix)
       : url_prefix_(url_prefix) {}
 
-  virtual SafeBrowsingService* CreateSafeBrowsingService() OVERRIDE {
+  virtual SafeBrowsingService* CreateSafeBrowsingService() override {
     return new FakeSafeBrowsingService(url_prefix_);
   }
 
  private:
   std::string url_prefix_;
 };
 
 // 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 base::FilePath& filename) OVERRIDE {}
+  virtual void Init(const base::FilePath& filename) override {}
 
   // Deletes the current database and creates a new one.
-  virtual bool ResetDatabase() OVERRIDE {
+  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::vector<SBPrefix>* prefix_hits,
-      std::vector<SBFullHashResult>* cache_hits) OVERRIDE {
+      std::vector<SBFullHashResult>* cache_hits) override {
     cache_hits->clear();
     return ContainsUrl(safe_browsing_util::MALWARE,
                        safe_browsing_util::PHISH,
                        std::vector<GURL>(1, url),
                        prefix_hits);
   }
   virtual bool ContainsDownloadUrl(
       const std::vector<GURL>& urls,
-      std::vector<SBPrefix>* prefix_hits) OVERRIDE {
+      std::vector<SBPrefix>* prefix_hits) override {
     bool found = ContainsUrl(safe_browsing_util::BINURL,
                              safe_browsing_util::BINURL,
                              urls,
                              prefix_hits);
     if (!found)
       return false;
     DCHECK_LE(1U, prefix_hits->size());
     return true;
   }
-  virtual bool ContainsCsdWhitelistedUrl(const GURL& url) OVERRIDE {
+  virtual bool ContainsCsdWhitelistedUrl(const GURL& url) override {
     return true;
   }
   virtual bool ContainsDownloadWhitelistedString(
-      const std::string& str) OVERRIDE {
+      const std::string& str) override {
     return true;
   }
-  virtual bool ContainsDownloadWhitelistedUrl(const GURL& url) OVERRIDE {
+  virtual bool ContainsDownloadWhitelistedUrl(const GURL& url) override {
     return true;
   }
   virtual bool ContainsExtensionPrefixes(
       const std::vector<SBPrefix>& prefixes,
-      std::vector<SBPrefix>* prefix_hits) OVERRIDE {
+      std::vector<SBPrefix>* prefix_hits) override {
     return true;
   }
-  virtual bool ContainsSideEffectFreeWhitelistUrl(const GURL& url) OVERRIDE {
+  virtual bool ContainsSideEffectFreeWhitelistUrl(const GURL& url) override {
     return true;
   }
-  virtual bool ContainsMalwareIP(const std::string& ip_address) OVERRIDE {
+  virtual bool ContainsMalwareIP(const std::string& ip_address) override {
     return true;
   }
-  virtual bool UpdateStarted(std::vector<SBListChunkRanges>* lists) OVERRIDE {
+  virtual bool UpdateStarted(std::vector<SBListChunkRanges>* lists) override {
     ADD_FAILURE() << "Not implemented.";
     return false;
   }
   virtual void InsertChunks(
       const std::string& list_name,
-      const std::vector<SBChunkData*>& chunks) OVERRIDE {
+      const std::vector<SBChunkData*>& chunks) override {
     ADD_FAILURE() << "Not implemented.";
   }
   virtual void DeleteChunks(
-      const std::vector<SBChunkDelete>& chunk_deletes) OVERRIDE {
+      const std::vector<SBChunkDelete>& chunk_deletes) override {
     ADD_FAILURE() << "Not implemented.";
   }
-  virtual void UpdateFinished(bool update_succeeded) OVERRIDE {
+  virtual void UpdateFinished(bool update_succeeded) override {
     ADD_FAILURE() << "Not implemented.";
   }
   virtual void CacheHashResults(
       const std::vector<SBPrefix>& prefixes,
       const std::vector<SBFullHashResult>& cache_hits,
-      const base::TimeDelta& cache_lifetime) OVERRIDE {
+      const base::TimeDelta& cache_lifetime) override {
     // Do nothing for the cache.
   }
-  virtual bool IsMalwareIPMatchKillSwitchOn() OVERRIDE {
+  virtual bool IsMalwareIPMatchKillSwitchOn() override {
     return false;
   }
-  virtual bool IsCsdWhitelistKillSwitchOn() OVERRIDE {
+  virtual bool IsCsdWhitelistKillSwitchOn() override {
     return false;
   }
 
   // Fill up the database with test URL.
   void AddUrl(const GURL& url,
               int list_id,
               const std::vector<SBPrefix>& prefix_hits) {
     badurls_[url.spec()].list_id = list_id;
     badurls_[url.spec()].prefix_hits = prefix_hits;
   }
@@ skipping 42 matching lines @@
  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_side_effect_free_whitelist,
-      bool enable_ip_blacklist) OVERRIDE {
+      bool enable_ip_blacklist) override {
     db_ = new TestSafeBrowsingDatabase();
     return db_;
   }
   TestSafeBrowsingDatabase* GetDb() {
     return db_;
   }
  private:
   // Owned by the SafebrowsingService.
   TestSafeBrowsingDatabase* db_;
 };
@@ skipping 14 matching lines @@
   }
 
   // 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,
       SafeBrowsingProtocolManager::FullHashCallback callback,
-      bool is_download) OVERRIDE {
+      bool is_download) override {
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(InvokeFullHashCallback, callback, full_hashes_),
         delay_);
   }
 
   // Prepare the GetFullHash results for the next request.
   void SetGetFullHashResponse(const SBFullHashResult& full_hash_result) {
     full_hashes_.clear();
     full_hashes_.push_back(full_hash_result);
@@ skipping 25 matching lines @@
 
 // Factory that creates TestProtocolManager instances.
 class TestSBProtocolManagerFactory : public SBProtocolManagerFactory {
  public:
   TestSBProtocolManagerFactory() : pm_(NULL) {}
   virtual ~TestSBProtocolManagerFactory() {}
 
   virtual SafeBrowsingProtocolManager* CreateProtocolManager(
       SafeBrowsingProtocolManagerDelegate* delegate,
       net::URLRequestContextGetter* request_context_getter,
-      const SafeBrowsingProtocolConfig& config) OVERRIDE {
+      const SafeBrowsingProtocolConfig& config) override {
     pm_ = new TestProtocolManager(delegate, request_context_getter, config);
     return pm_;
   }
 
   TestProtocolManager* GetProtocolManager() {
     return pm_;
   }
 
  private:
   // Owned by the SafebrowsingService.
@@ skipping 47 matching lines @@
   virtual void TearDown() {
     InProcessBrowserTest::TearDown();
 
     // Unregister test factories after InProcessBrowserTest::TearDown
     // (which destructs SafeBrowsingService).
     SafeBrowsingDatabase::RegisterFactory(NULL);
     SafeBrowsingProtocolManager::RegisterFactory(NULL);
     SafeBrowsingService::RegisterFactory(NULL);
   }
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     // Makes sure the auto update is not triggered during the test.
     // This test will fill up the database using testing prefixes
     // and urls.
     command_line->AppendSwitch(switches::kSbDisableAutoUpdate);
 #if defined(OS_CHROMEOS)
     command_line->AppendSwitch(
         chromeos::switches::kIgnoreUserProfileMappingForTests);
 #endif
   }
 
@@ skipping 88 matching lines @@
   METADATA_LANDING,
   METADATA_DISTRIBUTION,
 };
 
 class SafeBrowsingServiceMetadataTest
     : public SafeBrowsingServiceTest,
       public ::testing::WithParamInterface<MalwareMetadataTestType> {
  public:
   SafeBrowsingServiceMetadataTest() {}
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     SafeBrowsingServiceTest::SetUpOnMainThread();
     g_browser_process->safe_browsing_service()->ui_manager()->AddObserver(
         &observer_);
   }
 
-  virtual void TearDownOnMainThread() OVERRIDE {
+  virtual void TearDownOnMainThread() override {
     g_browser_process->safe_browsing_service()->ui_manager()->RemoveObserver(
         &observer_);
     SafeBrowsingServiceTest::TearDownOnMainThread();
   }
 
   void GenUrlFullhashResultWithMetadata(const GURL& url,
                                         SBFullHashResult* full_hash) {
     GenUrlFullhashResult(url, safe_browsing_util::MALWARE, full_hash);
 
     safe_browsing::MalwarePatternType proto;
@@ skipping 212 matching lines @@
   friend class base::RefCountedThreadSafe<TestSBClient>;
   virtual ~TestSBClient() {}
 
   void CheckDownloadUrlOnIOThread(const std::vector<GURL>& url_chain) {
     safe_browsing_service_->database_manager()->
         CheckDownloadUrl(url_chain, this);
   }
 
   // Called when the result of checking a download URL is known.
   virtual void OnCheckDownloadUrlResult(const std::vector<GURL>& url_chain,
-                                        SBThreatType threat_type) OVERRIDE {
+                                        SBThreatType threat_type) override {
     threat_type_ = threat_type;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&TestSBClient::DownloadCheckDone, this));
   }
 
   void DownloadCheckDone() {
     base::MessageLoopForUI::current()->Quit();
   }
 
   SBThreatType threat_type_;
@@ skipping 145 matching lines @@
   profile2.reset();
   WaitForIOThread();
   EXPECT_FALSE(sb_service->enabled());
   EXPECT_FALSE(csd_service->enabled());
 }
 
 }  // namespace
 
 class SafeBrowsingServiceShutdownTest : public SafeBrowsingServiceTest {
  public:
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Browser should be fully torn down by now, so we can safely check these
     // counters.
     EXPECT_EQ(1, TestProtocolManager::create_count());
     EXPECT_EQ(1, TestProtocolManager::delete_count());
 
     SafeBrowsingServiceTest::TearDown();
   }
 
   // An observer that returns back to test code after a new profile is
   // initialized.
@@ skipping 52 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 SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // We need to start the test server to get the host&port in the url.
     ASSERT_TRUE(test_server()->Start());
 
     // 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#");
     sb_factory_.reset(new TestSafeBrowsingServiceFactory(url_prefix.spec()));
     SafeBrowsingService::RegisterFactory(sb_factory_.get());
 
     InProcessBrowserTest::SetUp();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     InProcessBrowserTest::TearDown();
 
     SafeBrowsingService::RegisterFactory(NULL);
   }
 
-  virtual bool SetUpUserDataDirectory() OVERRIDE {
+  virtual bool SetUpUserDataDirectory() override {
     base::FilePath cookie_path(
         SafeBrowsingService::GetCookieFilePathForTesting());
     EXPECT_FALSE(base::PathExists(cookie_path));
 
     base::FilePath test_dir;
     if (!PathService::Get(chrome::DIR_TEST_DATA, &test_dir)) {
       EXPECT_TRUE(false);
       return false;
     }
 
@@ skipping 25 matching lines @@
       return false;
     }
     if (!smt.Run()) {
       EXPECT_TRUE(false);
       return false;
     }
 
     return InProcessBrowserTest::SetUpUserDataDirectory();
   }
 
-  virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
+  virtual void TearDownInProcessBrowserTestFixture() override {
     InProcessBrowserTest::TearDownInProcessBrowserTestFixture();
 
     sql::Connection db;
     base::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() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     sb_service_ = g_browser_process->safe_browsing_service();
     ASSERT_TRUE(sb_service_.get() != NULL);
   }
 
-  virtual void TearDownOnMainThread() OVERRIDE {
+  virtual void TearDownOnMainThread() override {
     sb_service_ = NULL;
   }
 
   void ForceUpdate() {
     sb_service_->protocol_manager()->ForceScheduleNextUpdate(
         base::TimeDelta::FromSeconds(0));
   }
 
   scoped_refptr<SafeBrowsingService> sb_service_;
 
@@ skipping 10 matching lines @@
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
           sb_service_->database_manager().get()));
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }