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

chrome/browser/safe_browsing/safe_browsing_blocking_page_test.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 fake safebrowsing service, where we can inject
 // malware and phishing urls.  It then uses a real browser to go to
 // these urls, and sends "goback" or "proceed" commands and verifies
 // they work.
 
 #include "base/bind.h"
@@ skipping 43 matching lines @@
 class FakeSafeBrowsingDatabaseManager :  public SafeBrowsingDatabaseManager {
  public:
   explicit FakeSafeBrowsingDatabaseManager(SafeBrowsingService* service)
       : SafeBrowsingDatabaseManager(service) { }
 
   // 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, and "client" is called asynchronously with the
   // result when it is ready.
   // Overrides SafeBrowsingDatabaseManager::CheckBrowseUrl.
-  virtual bool CheckBrowseUrl(const GURL& gurl, Client* client) OVERRIDE {
+  virtual bool CheckBrowseUrl(const GURL& gurl, Client* client) override {
     if (badurls[gurl.spec()] == SB_THREAT_TYPE_SAFE)
       return true;
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&FakeSafeBrowsingDatabaseManager::OnCheckBrowseURLDone,
                    this, gurl, client));
     return false;
   }
 
@@ skipping 23 matching lines @@
 };
 
 // A SafeBrowingUIManager class that allows intercepting malware details.
 class FakeSafeBrowsingUIManager :  public SafeBrowsingUIManager {
  public:
   explicit FakeSafeBrowsingUIManager(SafeBrowsingService* service) :
       SafeBrowsingUIManager(service) { }
 
   // Overrides SafeBrowsingUIManager
   virtual void SendSerializedMalwareDetails(
-      const std::string& serialized) OVERRIDE {
+      const std::string& serialized) override {
     // Notify the UI thread that we got a report.
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&FakeSafeBrowsingUIManager::OnMalwareDetailsDone,
                    this,
                    serialized));
   }
 
   void OnMalwareDetailsDone(const std::string& serialized) {
@@ skipping 41 matching lines @@
   }
   // Returned pointer has the same lifespan as the ui_manager_ refcounted
   // object.
   FakeSafeBrowsingUIManager* fake_ui_manager() {
     return fake_ui_manager_;
   }
 
  protected:
   virtual ~FakeSafeBrowsingService() { }
 
-  virtual SafeBrowsingDatabaseManager* CreateDatabaseManager() OVERRIDE {
+  virtual SafeBrowsingDatabaseManager* CreateDatabaseManager() override {
     fake_database_manager_ = new FakeSafeBrowsingDatabaseManager(this);
     return fake_database_manager_;
   }
 
-  virtual SafeBrowsingUIManager* CreateUIManager() OVERRIDE {
+  virtual SafeBrowsingUIManager* CreateUIManager() override {
     fake_ui_manager_ = new FakeSafeBrowsingUIManager(this);
     return fake_ui_manager_;
   }
 
  private:
   FakeSafeBrowsingDatabaseManager* fake_database_manager_;
   FakeSafeBrowsingUIManager* fake_ui_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingService);
 };
 
 // Factory that creates FakeSafeBrowsingService instances.
 class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
  public:
   TestSafeBrowsingServiceFactory() :
       most_recent_service_(NULL) { }
   virtual ~TestSafeBrowsingServiceFactory() { }
 
-  virtual SafeBrowsingService* CreateSafeBrowsingService() OVERRIDE {
+  virtual SafeBrowsingService* CreateSafeBrowsingService() override {
     most_recent_service_ =  new FakeSafeBrowsingService();
     return most_recent_service_;
   }
 
   FakeSafeBrowsingService* most_recent_service() const {
     return most_recent_service_;
   }
 
  private:
   FakeSafeBrowsingService* most_recent_service_;
 };
 
 // A MalwareDetails class lets us intercept calls from the renderer.
 class FakeMalwareDetails : public MalwareDetails {
  public:
   FakeMalwareDetails(
       SafeBrowsingUIManager* delegate,
       WebContents* web_contents,
       const SafeBrowsingUIManager::UnsafeResource& unsafe_resource)
       : MalwareDetails(delegate, web_contents, unsafe_resource),
         got_dom_(false),
         waiting_(false) { }
 
   virtual void AddDOMDetails(
       const std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node>& params)
-          OVERRIDE {
+          override {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     MalwareDetails::AddDOMDetails(params);
 
     // Notify the UI thread that we got the dom details.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&FakeMalwareDetails::OnDOMDetailsDone,
                                        this));
   }
 
   void WaitForDOM() {
@@ skipping 24 matching lines @@
 };
 
 class TestMalwareDetailsFactory : public MalwareDetailsFactory {
  public:
   TestMalwareDetailsFactory() : details_() { }
   virtual ~TestMalwareDetailsFactory() { }
 
   virtual MalwareDetails* CreateMalwareDetails(
       SafeBrowsingUIManager* delegate,
       WebContents* web_contents,
-      const SafeBrowsingUIManager::UnsafeResource& unsafe_resource) OVERRIDE {
+      const SafeBrowsingUIManager::UnsafeResource& unsafe_resource) override {
     details_ = new FakeMalwareDetails(delegate, web_contents,
                                       unsafe_resource);
     return details_;
   }
 
   FakeMalwareDetails* get_details() {
     return details_;
   }
 
  private:
@@ skipping 20 matching lines @@
     base::MessageLoopForUI::current()->Quit();
     wait_for_delete_ = false;
   }
 
   void WaitForDelete() {
     wait_for_delete_ = true;
     content::RunMessageLoop();
   }
 
   // InterstitialPageDelegate methods:
-  virtual void CommandReceived(const std::string& command) OVERRIDE {
+  virtual void CommandReceived(const std::string& command) override {
     SafeBrowsingBlockingPage::CommandReceived(command);
   }
-  virtual void OnProceed() OVERRIDE {
+  virtual void OnProceed() override {
     SafeBrowsingBlockingPage::OnProceed();
   }
-  virtual void OnDontProceed() OVERRIDE {
+  virtual void OnDontProceed() override {
     SafeBrowsingBlockingPage::OnDontProceed();
   }
 
  private:
   bool wait_for_delete_;
 };
 
 class TestSafeBrowsingBlockingPageFactory
     : public SafeBrowsingBlockingPageFactory {
  public:
   TestSafeBrowsingBlockingPageFactory() { }
   virtual ~TestSafeBrowsingBlockingPageFactory() { }
 
   virtual SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
       SafeBrowsingUIManager* delegate,
       WebContents* web_contents,
       const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources)
-          OVERRIDE {
+          override {
     return new TestSafeBrowsingBlockingPage(delegate, web_contents,
                                               unsafe_resources);
   }
 };
 
 }  // namespace
 
 // Tests the safe browsing blocking page in a browser.
 class SafeBrowsingBlockingPageBrowserTest
     : public InProcessBrowserTest,
       public testing::WithParamInterface<int> {
  public:
   enum Visibility {
     VISIBILITY_ERROR = -1,
     HIDDEN = 0,
     VISIBLE = 1
   };
 
   SafeBrowsingBlockingPageBrowserTest() {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     SafeBrowsingService::RegisterFactory(&factory_);
     SafeBrowsingBlockingPage::RegisterFactory(&blocking_page_factory_);
     MalwareDetails::RegisterFactory(&details_factory_);
     InProcessBrowserTest::SetUp();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     InProcessBrowserTest::TearDown();
     SafeBrowsingBlockingPage::RegisterFactory(NULL);
     SafeBrowsingService::RegisterFactory(NULL);
     MalwareDetails::RegisterFactory(NULL);
   }
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     ASSERT_TRUE(test_server()->Start());
   }
 
   void SetURLThreatType(const GURL& url, SBThreatType threat_type) {
     FakeSafeBrowsingService* service =
         static_cast<FakeSafeBrowsingService*>(
             g_browser_process->safe_browsing_service());
 
     ASSERT_TRUE(service);
     service->fake_database_manager()->SetURLThreatType(url, threat_type);
@@ skipping 465 matching lines @@
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageBrowserTest, PhishingLearnMore) {
   SetupWarningAndNavigate(SB_THREAT_TYPE_URL_PHISHING);
   EXPECT_TRUE(ClickAndWaitForDetach("help-link"));
   AssertNoInterstitial(false);  // Assert the interstitial is gone
 
   // We are in the help page.
   EXPECT_EQ(
       "/transparencyreport/safebrowsing/",
        browser()->tab_strip_model()->GetActiveWebContents()->GetURL().path());
 }