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

chrome/browser/autofill/autofill_server_browsertest.cc

 // Copyright 2014 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/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
@@ skipping 17 matching lines @@
 
 // TODO(isherman): Similar classes are defined in a few other Autofill browser
 // tests. It would be good to factor out the shared code into a helper file.
 class WindowedPersonalDataManagerObserver : public PersonalDataManagerObserver {
  public:
   explicit WindowedPersonalDataManagerObserver(Profile* profile)
       : profile_(profile),
         message_loop_runner_(new content::MessageLoopRunner){
     PersonalDataManagerFactory::GetForProfile(profile_)->AddObserver(this);
   }
-  virtual ~WindowedPersonalDataManagerObserver() {}
+  ~WindowedPersonalDataManagerObserver() override {}
 
   // Waits for the PersonalDataManager's list of profiles to be updated.
   void Wait() {
     message_loop_runner_->Run();
     PersonalDataManagerFactory::GetForProfile(profile_)->RemoveObserver(this);
   }
 
   // PersonalDataManagerObserver:
-  virtual void OnPersonalDataChanged() override {
-    message_loop_runner_->Quit();
-  }
+  void OnPersonalDataChanged() override { message_loop_runner_->Quit(); }
 
  private:
   Profile* profile_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 };
 
 class WindowedNetworkObserver : public net::TestURLFetcher::DelegateForTests {
  public:
   explicit WindowedNetworkObserver(const std::string& expected_upload_data)
       : factory_(new net::TestURLFetcherFactory),
         expected_upload_data_(expected_upload_data),
         message_loop_runner_(new content::MessageLoopRunner) {
     factory_->SetDelegateForTests(this);
   }
   ~WindowedNetworkObserver() {}
 
   // Waits for a network request with the |expected_upload_data_|.
   void Wait() {
     message_loop_runner_->Run();
     factory_.reset();
   }
 
   // net::TestURLFetcher::DelegateForTests:
-  virtual void OnRequestStart(int fetcher_id) override {
+  void OnRequestStart(int fetcher_id) override {
     net::TestURLFetcher* fetcher = factory_->GetFetcherByID(fetcher_id);
     if (fetcher->upload_data() == expected_upload_data_)
       message_loop_runner_->Quit();
 
     // Not interested in any further status updates from this fetcher.
     fetcher->SetDelegateForTests(NULL);
   }
-  virtual void OnChunkUpload(int fetcher_id) override {}
-  virtual void OnRequestEnd(int fetcher_id) override {}
+  void OnChunkUpload(int fetcher_id) override {}
+  void OnRequestEnd(int fetcher_id) override {}
 
  private:
   // Mocks out network requests.
   scoped_ptr<net::TestURLFetcherFactory> factory_;
 
   const std::string expected_upload_data_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowedNetworkObserver);
 };
 
 }  // namespace
 
 class AutofillServerTest : public InProcessBrowserTest  {
  public:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     // Disable interactions with the Mac Keychain.
     PrefService* pref_service = browser()->profile()->GetPrefs();
     test::DisableSystemServices(pref_service);
 
     // Enable uploads, and load a new tab to force the AutofillDownloadManager
     // to update its cached view of the prefs.
     pref_service->SetDouble(prefs::kAutofillPositiveUploadRate, 1.0);
     pref_service->SetDouble(prefs::kAutofillNegativeUploadRate, 1.0);
     AddBlankTabAndShow(browser());
   }
@@ skipping 56 matching lines @@
       "</autofillupload>";
   WindowedNetworkObserver upload_network_observer(kUploadRequest);
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   content::SimulateMouseClick(
       web_contents, 0, blink::WebMouseEvent::ButtonLeft);
   upload_network_observer.Wait();
 }
 
 }  // namespace autofill