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

chrome/browser/captive_portal/captive_portal_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 <map>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 98 matching lines @@
 // captive portal.
 const char* const kInternetConnectedTitle = "Title Of Awesomeness";
 
 // A URL request job that hangs until FailJobs() is called.  Started jobs
 // are stored in a static class variable containing a linked list so that
 // FailJobs() can locate them.
 class URLRequestTimeoutOnDemandJob : public net::URLRequestJob,
                                      public base::NonThreadSafe {
  public:
   // net::URLRequestJob:
-  virtual void Start() override;
+  void Start() override;
 
   // All the public static methods below can be called on any thread.
 
   // Waits for exactly |num_jobs|.
   static void WaitForJobs(int num_jobs);
 
   // Fails all active URLRequestTimeoutOnDemandJobs with connection timeouts.
   // There are expected to be exactly |expected_num_jobs| waiting for
   // failure.  The only way to gaurantee this is with an earlier call to
   // WaitForJobs, so makes sure there has been a matching WaitForJobs call.
   static void FailJobs(int expected_num_jobs);
 
   // Abandon all active URLRequestTimeoutOnDemandJobs.  |expected_num_jobs|
   // behaves just as in FailJobs.
   static void AbandonJobs(int expected_num_jobs);
 
  private:
   friend class URLRequestMockCaptivePortalJobFactory;
 
   // Operation to perform on jobs when removing them from |job_list_|.
   enum EndJobOperation {
     FAIL_JOBS,
     ABANDON_JOBS,
   };
 
   URLRequestTimeoutOnDemandJob(net::URLRequest* request,
                                net::NetworkDelegate* network_delegate);
-  virtual ~URLRequestTimeoutOnDemandJob();
+  ~URLRequestTimeoutOnDemandJob() override;
 
   // Attempts to removes |this| from |jobs_|.  Returns true if it was removed
   // from the list.
   bool RemoveFromList();
 
   static void WaitForJobsOnIOThread(int num_jobs);
   static void FailOrAbandonJobsOnIOThread(
       int expected_num_jobs,
       EndJobOperation end_job_operation);
 
@@ skipping 338 matching lines @@
 bool IsLoginTab(WebContents* web_contents) {
   return CaptivePortalTabHelper::FromWebContents(web_contents)->IsLoginTab();
 }
 
 // Tracks how many times each tab has been navigated since the Observer was
 // created.  The standard TestNavigationObserver can only watch specific
 // pre-existing tabs or loads in serial for all tabs.
 class MultiNavigationObserver : public content::NotificationObserver {
  public:
   MultiNavigationObserver();
-  virtual ~MultiNavigationObserver();
+  ~MultiNavigationObserver() override;
 
   // Waits for exactly |num_navigations_to_wait_for| LOAD_STOP
   // notifications to have occurred since the construction of |this|.  More
   // navigations than expected occuring will trigger a expect failure.
   void WaitForNavigations(int num_navigations_to_wait_for);
 
   // Returns the number of LOAD_STOP events that have occurred for
   // |web_contents| since this was constructed.
   int NumNavigationsForTab(WebContents* web_contents) const;
 
   // The number of LOAD_STOP events since |this| was created.
   int num_navigations() const { return num_navigations_; }
 
  private:
   typedef std::map<const WebContents*, int> TabNavigationMap;
 
   // content::NotificationObserver:
-  virtual void Observe(int type, const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override;
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override;
 
   int num_navigations_;
 
   // Map of how many times each tab has navigated since |this| was created.
   TabNavigationMap tab_navigation_map_;
 
   // Total number of navigations to wait for.  Value only matters when
   // |waiting_for_navigation_| is true.
   int num_navigations_to_wait_for_;
 
@@ skipping 60 matching lines @@
 // to stop loading and have the kInternetConnectedTitle.
 //
 // This is for the specific purpose of observing tabs time out after logging in
 // to a captive portal, which will then cause them to reload.
 // MultiNavigationObserver is insufficient for this because there may or may not
 // be a LOAD_STOP event between the timeout and the reload.
 // See bug http://crbug.com/133227
 class FailLoadsAfterLoginObserver : public content::NotificationObserver {
  public:
   FailLoadsAfterLoginObserver();
-  virtual ~FailLoadsAfterLoginObserver();
+  ~FailLoadsAfterLoginObserver() override;
 
   void WaitForNavigations();
 
  private:
   typedef std::set<const WebContents*> TabSet;
 
   // content::NotificationObserver:
-  virtual void Observe(int type, const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override;
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override;
 
   // The set of tabs that need to be navigated.  This is the set of loading
   // tabs when the observer is created.
   TabSet tabs_needing_navigation_;
 
   // Number of tabs that have stopped navigating with the expected title.  These
   // are expected not to be navigated again.
   TabSet tabs_navigated_to_final_destination_;
 
   // True if WaitForNavigations has been called, until
@@ skipping 67 matching lines @@
   void WaitForResults(int num_results_to_wait_for);
 
   int num_results_received() const { return num_results_received_; }
 
   CaptivePortalResult captive_portal_result() const {
     return captive_portal_result_;
   }
 
  private:
   // Records results and exits the message loop, if needed.
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override;
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override;
 
   // Number of times OnPortalResult has been called since construction.
   int num_results_received_;
 
   // If WaitForResults was called, the total number of updates for which to
   // wait.  Value doesn't matter when |waiting_for_result_| is false.
   int num_results_to_wait_for_;
 
   bool waiting_for_result_;
 
@@ skipping 76 matching lines @@
   transport_security_state->AddHSTS(host, expiry, include_subdomains);
 }
 
 }  // namespace
 
 class CaptivePortalBrowserTest : public InProcessBrowserTest {
  public:
   CaptivePortalBrowserTest();
 
   // InProcessBrowserTest:
-  virtual void SetUpOnMainThread() override;
-  virtual void TearDownOnMainThread() override;
+  void SetUpOnMainThread() override;
+  void TearDownOnMainThread() override;
 
   // Sets the captive portal checking preference.  Does not affect the command
   // line flag, which is set in SetUpCommandLine.
   void EnableCaptivePortalDetection(Profile* profile, bool enabled);
 
   // Sets up the captive portal service for the given profile so that
   // all checks go to |test_url|.  Also disables all timers.
   void SetUpCaptivePortalService(Profile* profile, const GURL& test_url);
 
   // Returns true if |browser|'s profile is currently running a captive portal
@@ skipping 1390 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&AddHstsHost,
                  make_scoped_refptr(browser()->profile()->GetRequestContext()),
                  http_timeout_url.host()));
 
   SlowLoadBehindCaptivePortal(browser(), true, http_timeout_url, 1, 1);
   Login(browser(), 1, 0);
   FailLoadsAfterLogin(browser(), 1);
 }