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

chrome/browser/password_manager/password_manager_browsertest.cc

 // Copyright 2013 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 <string>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/path_service.h"
@@ skipping 49 matching lines @@
 namespace {
 
 // Observer that waits for navigation to complete and for the password infobar
 // to be shown.
 class NavigationObserver : public content::WebContentsObserver {
  public:
   explicit NavigationObserver(content::WebContents* web_contents)
       : content::WebContentsObserver(web_contents),
         message_loop_runner_(new content::MessageLoopRunner) {}
 
-  virtual ~NavigationObserver() {}
+  ~NavigationObserver() override {}
 
   // Normally Wait() will not return until a main frame navigation occurs.
   // If a path is set, Wait() will return after this path has been seen,
   // regardless of the frame that navigated. Useful for multi-frame pages.
   void SetPathToWaitFor(const std::string& path) {
     wait_for_path_ = path;
   }
 
   // content::WebContentsObserver:
-  virtual void DidFinishLoad(content::RenderFrameHost* render_frame_host,
-                             const GURL& validated_url) override {
+  void DidFinishLoad(content::RenderFrameHost* render_frame_host,
+                     const GURL& validated_url) override {
     if (!wait_for_path_.empty()) {
       if (validated_url.path() == wait_for_path_)
         message_loop_runner_->Quit();
     } else if (!render_frame_host->GetParent()) {
       message_loop_runner_->Quit();
     }
   }
 
   void Wait() { message_loop_runner_->Run(); }
 
@@ skipping 39 matching lines @@
 
 class InfoBarObserver : public PromptObserver,
                         public infobars::InfoBarManager::Observer {
  public:
   explicit InfoBarObserver(content::WebContents* web_contents)
       : infobar_is_being_shown_(false),
         infobar_service_(InfoBarService::FromWebContents(web_contents)) {
     infobar_service_->AddObserver(this);
   }
 
-  virtual ~InfoBarObserver() {
+  ~InfoBarObserver() override {
     if (infobar_service_)
       infobar_service_->RemoveObserver(this);
   }
 
  private:
   // PromptObserver:
-  virtual bool IsShowingPrompt() const override {
-    return infobar_is_being_shown_;
-  }
+  bool IsShowingPrompt() const override { return infobar_is_being_shown_; }
 
-  virtual void AcceptImpl() const override {
+  void AcceptImpl() const override {
     EXPECT_EQ(1u, infobar_service_->infobar_count());
     if (!infobar_service_->infobar_count())
       return;  // Let the test finish to gather possibly more diagnostics.
 
     // ConfirmInfoBarDelegate::Accept returning true means the infobar is
     // immediately closed. Checking the return value is preferred to testing
     // IsShowingPrompt() here, for it avoids the delay until the closing
     // notification is received.
     EXPECT_TRUE(infobar_service_->infobar_at(0)
                     ->delegate()
                     ->AsConfirmInfoBarDelegate()
                     ->Accept());
   }
 
   // infobars::InfoBarManager::Observer:
-  virtual void OnInfoBarAdded(infobars::InfoBar* infobar) override {
+  void OnInfoBarAdded(infobars::InfoBar* infobar) override {
     infobar_is_being_shown_ = true;
   }
 
-  virtual void OnInfoBarRemoved(infobars::InfoBar* infobar,
-                                bool animate) override {
+  void OnInfoBarRemoved(infobars::InfoBar* infobar, bool animate) override {
     infobar_is_being_shown_ = false;
   }
 
-  virtual void OnManagerShuttingDown(
-      infobars::InfoBarManager* manager) override {
+  void OnManagerShuttingDown(infobars::InfoBarManager* manager) override {
     ASSERT_EQ(infobar_service_, manager);
     infobar_service_->RemoveObserver(this);
     infobar_service_ = NULL;
   }
 
   bool infobar_is_being_shown_;
   InfoBarService* infobar_service_;
 
   DISALLOW_COPY_AND_ASSIGN(InfoBarObserver);
 };
 
 class BubbleObserver : public PromptObserver {
  public:
   explicit BubbleObserver(content::WebContents* web_contents)
       : ui_controller_(
             ManagePasswordsUIController::FromWebContents(web_contents)) {}
 
-  virtual ~BubbleObserver() {}
+  ~BubbleObserver() override {}
 
  private:
   // PromptObserver:
-  virtual bool IsShowingPrompt() const override {
+  bool IsShowingPrompt() const override {
     return ui_controller_->PasswordPendingUserDecision();
   }
 
-  virtual void AcceptImpl() const override {
+  void AcceptImpl() const override {
     ui_controller_->SavePassword();
     EXPECT_FALSE(IsShowingPrompt());
   }
 
   ManagePasswordsUIController* const ui_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleObserver);
 };
 
 GURL GetFileURL(const char* filename) {
@@ skipping 42 matching lines @@
 
 
 // PasswordManagerBrowserTest -------------------------------------------------
 
 class PasswordManagerBrowserTest : public InProcessBrowserTest {
  public:
   PasswordManagerBrowserTest() {}
   virtual ~PasswordManagerBrowserTest() {}
 
   // InProcessBrowserTest:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     // Use TestPasswordStore to remove a possible race. Normally the
     // PasswordStore does its database manipulation on the DB thread, which
     // creates a possible race during navigation. Specifically the
     // PasswordManager will ignore any forms in a page if the load from the
     // PasswordStore has not completed.
     PasswordStoreFactory::GetInstance()->SetTestingFactory(
         browser()->profile(), TestPasswordStoreService::Build);
     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
     ASSERT_FALSE(CommandLine::ForCurrentProcess()->HasSwitch(
         password_manager::switches::kEnableAutomaticPasswordSaving));
   }
 
-  virtual void TearDownOnMainThread() override {
+  void TearDownOnMainThread() override {
     ASSERT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
   }
 
  protected:
   content::WebContents* WebContents() {
     return browser()->tab_strip_model()->GetActiveWebContents();
   }
 
   content::RenderViewHost* RenderViewHost() {
     return WebContents()->GetRenderViewHost();
@@ skipping 982 matching lines @@
   NavigateToFile("/password/form_with_only_password_field.html");
 
   // Let the user interact with the page, so that DOM gets modification events,
   // needed for autofilling fields.
   content::SimulateMouseClickAt(
       WebContents(), 0, blink::WebMouseEvent::ButtonLeft, gfx::Point(1, 1));
 
   // Wait until that interaction causes the password value to be revealed.
   WaitForElementValue("password", "mypassword");
 }