Standardize usage of virtual/override/final in chrome/browser/

chrome/browser/errorpage_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.
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 136 matching lines @@
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
       url, handler.Pass());
 }
 
 // An interceptor that fails a configurable number of requests, then succeeds
 // all requests after that, keeping count of failures and successes.
 class FailFirstNRequestsInterceptor : public net::URLRequestInterceptor {
  public:
   explicit FailFirstNRequestsInterceptor(int requests_to_fail)
       : requests_(0), failures_(0), requests_to_fail_(requests_to_fail) {}
-  virtual ~FailFirstNRequestsInterceptor() {}
+  ~FailFirstNRequestsInterceptor() override {}
 
   // net::URLRequestInterceptor implementation
-  virtual net::URLRequestJob* MaybeInterceptRequest(
+  net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     requests_++;
     if (failures_ < requests_to_fail_) {
       failures_++;
       // Note: net::ERR_CONNECTION_RESET does not summon the Link Doctor; see
       // NetErrorHelperCore::GetErrorPageURL.
       return new URLRequestFailedJob(request,
                                      network_delegate,
@@ skipping 22 matching lines @@
 // An interceptor that serves LinkDoctor responses.  It also allows waiting
 // until a certain number of requests have been sent.
 // TODO(mmenke):  Wait until responses have been received instead.
 class LinkDoctorInterceptor : public net::URLRequestInterceptor {
  public:
   LinkDoctorInterceptor() : num_requests_(0),
                             requests_to_wait_for_(-1),
                             weak_factory_(this) {
   }
 
-  virtual ~LinkDoctorInterceptor() {}
+  ~LinkDoctorInterceptor() override {}
 
   // net::URLRequestInterceptor implementation
-  virtual net::URLRequestJob* MaybeInterceptRequest(
+  net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&LinkDoctorInterceptor::RequestCreated,
                    weak_factory_.GetWeakPtr()));
 
     base::FilePath root_http;
@@ skipping 73 matching lines @@
   enum HistoryNavigationDirection {
     HISTORY_NAVIGATE_BACK,
     HISTORY_NAVIGATE_FORWARD,
   };
 
   ErrorPageTest() : link_doctor_interceptor_(NULL) {}
   virtual ~ErrorPageTest() {}
 
   // Navigates the active tab to a mock url created for the file at |file_path|.
   // Needed for StaleCacheStatus and StaleCacheStatusFailedCorrections tests.
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kEnableOfflineLoadStaleCache);
   }
 
   // Navigates the active tab to a mock url created for the file at |file_path|.
   void NavigateToFileURL(const base::FilePath::StringType& file_path) {
     ui_test_utils::NavigateToURL(
         browser(),
         net::URLRequestMockHTTPJob::GetMockUrl(base::FilePath(file_path)));
   }
 
@@ skipping 87 matching lines @@
       return testing::AssertionFailure();
     return ("success" == result ? testing::AssertionSuccess() :
             (testing::AssertionFailure() << "Exception message is " << result));
   }
 
   LinkDoctorInterceptor* link_doctor_interceptor() {
     return link_doctor_interceptor_;
   }
 
  protected:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     link_doctor_interceptor_ = new LinkDoctorInterceptor();
     scoped_ptr<net::URLRequestInterceptor> owned_interceptor(
         link_doctor_interceptor_);
     // Ownership of the |interceptor_| is passed to an object the IO thread, but
     // a pointer is kept in the test fixture.  As soon as anything calls
     // URLRequestFilter::ClearHandlers(), |interceptor_| can become invalid.
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&InstallMockInterceptors,
                    google_util::GetGoogleSearchURL(
@@ skipping 38 matching lines @@
     test_navigation_observer.Wait();
   }
 
   LinkDoctorInterceptor* link_doctor_interceptor_;
 };
 
 class TestFailProvisionalLoadObserver : public content::WebContentsObserver {
  public:
   explicit TestFailProvisionalLoadObserver(content::WebContents* contents)
       : content::WebContentsObserver(contents) {}
-  virtual ~TestFailProvisionalLoadObserver() {}
+  ~TestFailProvisionalLoadObserver() override {}
 
   // This method is invoked when the provisional load failed.
-  virtual void DidFailProvisionalLoad(
+  void DidFailProvisionalLoad(
       content::RenderFrameHost* render_frame_host,
       const GURL& validated_url,
       int error_code,
       const base::string16& error_description) override {
     fail_url_ = validated_url;
   }
 
   const GURL& fail_url() const { return fail_url_; }
 
  private:
@@ skipping 388 matching lines @@
                   BrowsingDataHelper::UNPROTECTED_WEB);
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), test_url, 1);
   EXPECT_TRUE(ProbeStaleCopyValue(false));
   EXPECT_FALSE(IsDisplayingText(browser(), GetLoadStaleButtonLabel()));
   EXPECT_EQ(0, link_doctor_interceptor()->num_requests());
 }
 
 class ErrorPageAutoReloadTest : public InProcessBrowserTest {
  public:
-  virtual void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kEnableOfflineAutoReload);
   }
 
   void InstallInterceptor(const GURL& url, int requests_to_fail) {
     interceptor_ = new FailFirstNRequestsInterceptor(requests_to_fail);
     scoped_ptr<net::URLRequestInterceptor> owned_interceptor(interceptor_);
 
     // Tests don't need to wait for this task to complete before using the
     // filter; any requests that might be affected by it will end up in the IO
     // thread's message loop after this posted task anyway.
@@ skipping 39 matching lines @@
   // created (on the IO thread) before NavigateToURLAndWaitForTitle returns or
   // this becomes racey.
   EXPECT_EQ(kRequestsToFail, interceptor()->failures());
   EXPECT_EQ(kRequestsToFail + 1, interceptor()->requests());
 }
 
 // Interceptor that fails all requests with net::ERR_ADDRESS_UNREACHABLE.
 class AddressUnreachableInterceptor : public net::URLRequestInterceptor {
  public:
   AddressUnreachableInterceptor() {}
-  virtual ~AddressUnreachableInterceptor() {}
+  ~AddressUnreachableInterceptor() override {}
 
   // net::URLRequestInterceptor:
-  virtual net::URLRequestJob* MaybeInterceptRequest(
+  net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
     return new URLRequestFailedJob(request,
                                    network_delegate,
                                    net::ERR_ADDRESS_UNREACHABLE);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AddressUnreachableInterceptor);
 };
 
 // A test fixture that returns ERR_ADDRESS_UNREACHABLE for all navigation
 // correction requests.  ERR_NAME_NOT_RESOLVED is more typical, but need to use
 // a different error for the correction service and the original page to
 // validate the right page is being displayed.
 class ErrorPageNavigationCorrectionsFailTest : public ErrorPageTest {
  public:
   // InProcessBrowserTest:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ErrorPageNavigationCorrectionsFailTest::AddFilters));
   }
 
-  virtual void TearDownOnMainThread() override {
+  void TearDownOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ErrorPageNavigationCorrectionsFailTest::RemoveFilters));
   }
 
  private:
   // Adds a filter that causes all correction service requests to fail with
   // ERR_ADDRESS_UNREACHABLE.
   //
   // Also adds the net::URLRequestFailedJob filter.
@@ skipping 73 matching lines @@
 }
 
 // A test fixture that simulates failing requests for an IDN domain name.
 class ErrorPageForIDNTest : public InProcessBrowserTest {
  public:
   // Target hostname in different forms.
   static const char kHostname[];
   static const char kHostnameJSUnicode[];
 
   // InProcessBrowserTest:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     // Clear AcceptLanguages to force punycode decoding.
     browser()->profile()->GetPrefs()->SetString(prefs::kAcceptLanguages,
                                                 std::string());
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ErrorPageForIDNTest::AddFilters));
   }
 
-  virtual void TearDownOnMainThread() override {
+  void TearDownOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ErrorPageForIDNTest::RemoveFilters));
   }
 
  private:
   static void AddFilters() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     URLRequestFailedJob::AddUrlHandlerForHostname(kHostname);
   }
@@ skipping 17 matching lines @@
       browser(),
       URLRequestFailedJob::GetMockHttpUrlForHostname(net::ERR_UNSAFE_PORT,
                                                      kHostname),
       1);
 
   ToggleHelpBox(browser());
   EXPECT_TRUE(IsDisplayingText(browser(), kHostnameJSUnicode));
 }
 
 }  // namespace