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

chrome/browser/safe_browsing/safe_browsing_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 uses the safebrowsing test server published at
 // http://code.google.com/p/google-safe-browsing/ to test the safebrowsing
 // protocol implemetation. Details of the safebrowsing testing flow is
 // documented at
 // http://code.google.com/p/google-safe-browsing/wiki/ProtocolTesting
 //
@@ skipping 94 matching lines @@
     phishing_urls->push_back(phishing_url);
   }
   return true;
 }
 
 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_;
 };
 
 }  // namespace
 
 // This starts the browser and keeps status of states related to SafeBrowsing.
@@ skipping 95 matching lines @@
   const net::SpawnedTestServer& test_server() const {
     return *test_server_;
   }
 
  protected:
   bool InitSafeBrowsingService() {
     safe_browsing_service_ = g_browser_process->safe_browsing_service();
     return safe_browsing_service_ != NULL;
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     base::FilePath datafile_path;
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &datafile_path));
 
     datafile_path = datafile_path.Append(FILE_PATH_LITERAL("third_party"))
           .Append(FILE_PATH_LITERAL("safe_browsing"))
           .Append(FILE_PATH_LITERAL("testing"))
           .Append(kDataFile);
     test_server_.reset(new LocalSafeBrowsingTestServer(datafile_path));
     ASSERT_TRUE(test_server_->Start());
     LOG(INFO) << "server is " << test_server_->host_port_pair().ToString();
 
     // Point to the testing server for all SafeBrowsing requests.
     std::string url_prefix = test_server_->GetURL("safebrowsing").spec();
     sb_factory_.reset(new TestSafeBrowsingServiceFactory(url_prefix));
     SafeBrowsingService::RegisterFactory(sb_factory_.get());
 
     InProcessBrowserTest::SetUp();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     InProcessBrowserTest::TearDown();
 
     SafeBrowsingService::RegisterFactory(NULL);
   }
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     // This test uses loopback. No need to use IPv6 especially it makes
     // local requests slow on Windows trybot when ipv6 local address [::1]
     // is not setup.
     command_line->AppendSwitch(switches::kDisableIPv6);
 
     // TODO(lzheng): The test server does not understand download related
     // requests. We need to fix the server.
     command_line->AppendSwitch(switches::kSbDisableDownloadProtection);
 
     // TODO(gcasto): Generate new testing data that includes the
@@ skipping 49 matching lines @@
   SafeBrowsingServerTestHelper(SafeBrowsingServerTest* safe_browsing_test,
                                net::URLRequestContextGetter* request_context)
       : safe_browsing_test_(safe_browsing_test),
         response_status_(net::URLRequestStatus::FAILED),
         request_context_(request_context) {
   }
 
   // Callbacks for SafeBrowsingDatabaseManager::Client.
   virtual void OnCheckBrowseUrlResult(const GURL& url,
                                       SBThreatType threat_type,
-                                      const std::string& metadata) OVERRIDE {
+                                      const std::string& metadata) override {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     EXPECT_TRUE(safe_browsing_test_->is_checked_url_in_db());
     safe_browsing_test_->set_is_checked_url_safe(
         threat_type == SB_THREAT_TYPE_SAFE);
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&SafeBrowsingServerTestHelper::OnCheckUrlDone, this));
   }
 
   virtual void OnBlockingPageComplete(bool proceed) {
     NOTREACHED() << "Not implemented.";
@@ skipping 81 matching lines @@
   // this verification will fail.
   net::URLRequestStatus::Status VerifyTestComplete(
       const net::SpawnedTestServer& test_server,
       int test_step) {
     std::string path = base::StringPrintf(
         "%s?test_step=%d", kTestCompletePath, test_step);
     return FetchUrl(test_server.GetURL(path));
   }
 
   // Callback for URLFetcher.
-  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE {
+  virtual void OnURLFetchComplete(const net::URLFetcher* source) override {
     source->GetResponseAsString(&response_data_);
     response_status_ = source->GetStatus().status();
     StopUILoop();
   }
 
   const std::string& response_data() {
     return response_data_;
   }
 
  private:
@@ skipping 106 matching lines @@
               safe_browsing_helper->FetchDBToVerify(test_server(), step));
     EXPECT_GT(safe_browsing_helper->response_data().size(), 0U);
     last_step = step;
   }
 
   // Verifies with server if test is done and waits till server responses.
   EXPECT_EQ(net::URLRequestStatus::SUCCESS,
             safe_browsing_helper->VerifyTestComplete(test_server(), last_step));
   EXPECT_EQ("yes", safe_browsing_helper->response_data());
 }