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

content/browser/web_contents/web_contents_impl_unittest.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/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/frame_host/cross_site_transferring_request.h"
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/media/audio_stream_monitor.h"
@@ skipping 26 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 namespace {
 
 const char kTestWebUIUrl[] = "chrome://blah";
 
 class WebContentsImplTestWebUIControllerFactory
     : public WebUIControllerFactory {
  public:
-  virtual WebUIController* CreateWebUIControllerForURL(
-      WebUI* web_ui, const GURL& url) const override {
+  WebUIController* CreateWebUIControllerForURL(WebUI* web_ui,
+                                               const GURL& url) const override {
     if (!UseWebUI(url))
       return NULL;
     return new WebUIController(web_ui);
   }
 
-  virtual WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
-      const GURL& url) const override {
+  WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
+                             const GURL& url) const override {
     return WebUI::kNoWebUI;
   }
 
-  virtual bool UseWebUIForURL(BrowserContext* browser_context,
+  bool UseWebUIForURL(BrowserContext* browser_context,
+                      const GURL& url) const override {
+    return UseWebUI(url);
+  }
+
+  bool UseWebUIBindingsForURL(BrowserContext* browser_context,
                               const GURL& url) const override {
     return UseWebUI(url);
   }
 
-  virtual bool UseWebUIBindingsForURL(BrowserContext* browser_context,
-                                      const GURL& url) const override {
-    return UseWebUI(url);
-  }
-
  private:
   bool UseWebUI(const GURL& url) const {
     return url == GURL(kTestWebUIUrl);
   }
 };
 
 class TestInterstitialPage;
 
 class TestInterstitialPageDelegate : public InterstitialPageDelegate {
  public:
   explicit TestInterstitialPageDelegate(TestInterstitialPage* interstitial_page)
       : interstitial_page_(interstitial_page) {}
-  virtual void CommandReceived(const std::string& command) override;
-  virtual std::string GetHTMLContents() override { return std::string(); }
-  virtual void OnDontProceed() override;
-  virtual void OnProceed() override;
+  void CommandReceived(const std::string& command) override;
+  std::string GetHTMLContents() override { return std::string(); }
+  void OnDontProceed() override;
+  void OnProceed() override;
+
  private:
   TestInterstitialPage* interstitial_page_;
 };
 
 class TestInterstitialPage : public InterstitialPageImpl {
  public:
   enum InterstitialState {
     INVALID = 0,    // Hasn't yet been initialized.
     UNDECIDED,      // Initialized, but no decision taken yet.
     OKED,           // Proceed was called.
@@ skipping 28 matching lines @@
             static_cast<RenderWidgetHostDelegate*>(contents),
             new_navigation, url, new TestInterstitialPageDelegate(this)),
         state_(state),
         deleted_(deleted),
         command_received_count_(0),
         delegate_(NULL) {
     *state_ = UNDECIDED;
     *deleted_ = false;
   }
 
-  virtual ~TestInterstitialPage() {
+  ~TestInterstitialPage() override {
     if (deleted_)
       *deleted_ = true;
     if (delegate_)
       delegate_->TestInterstitialPageDeleted(this);
   }
 
   void OnDontProceed() {
     if (state_)
       *state_ = CANCELED;
   }
@@ skipping 35 matching lines @@
 
   void CommandReceived() {
     command_received_count_++;
   }
 
   void set_delegate(Delegate* delegate) {
     delegate_ = delegate;
   }
 
  protected:
-  virtual WebContentsView* CreateWebContentsView() override {
-    return NULL;
-  }
+  WebContentsView* CreateWebContentsView() override { return NULL; }
 
  private:
   InterstitialState* state_;
   bool* deleted_;
   int command_received_count_;
   Delegate* delegate_;
 };
 
 void TestInterstitialPageDelegate::CommandReceived(const std::string& command) {
   interstitial_page_->CommandReceived();
 }
 
 void TestInterstitialPageDelegate::OnDontProceed() {
   interstitial_page_->OnDontProceed();
 }
 
 void TestInterstitialPageDelegate::OnProceed() {
   interstitial_page_->OnProceed();
 }
 
 class TestInterstitialPageStateGuard : public TestInterstitialPage::Delegate {
  public:
   explicit TestInterstitialPageStateGuard(
       TestInterstitialPage* interstitial_page)
       : interstitial_page_(interstitial_page) {
     DCHECK(interstitial_page_);
     interstitial_page_->set_delegate(this);
   }
-  virtual ~TestInterstitialPageStateGuard() {
+  ~TestInterstitialPageStateGuard() override {
     if (interstitial_page_)
       interstitial_page_->ClearStates();
   }
 
-  virtual void TestInterstitialPageDeleted(
+  void TestInterstitialPageDeleted(
       TestInterstitialPage* interstitial) override {
     DCHECK(interstitial_page_ == interstitial);
     interstitial_page_ = NULL;
   }
 
  private:
   TestInterstitialPage* interstitial_page_;
 };
 
 class WebContentsImplTestBrowserClient : public TestContentBrowserClient {
  public:
   WebContentsImplTestBrowserClient()
       : assign_site_for_url_(false) {}
 
-  virtual ~WebContentsImplTestBrowserClient() {}
+  ~WebContentsImplTestBrowserClient() override {}
 
-  virtual bool ShouldAssignSiteForURL(const GURL& url) override {
+  bool ShouldAssignSiteForURL(const GURL& url) override {
     return assign_site_for_url_;
   }
 
   void set_assign_site_for_url(bool assign) {
     assign_site_for_url_ = assign;
   }
 
  private:
   bool assign_site_for_url_;
 };
@@ skipping 12 matching lines @@
 
  private:
   WebContentsImplTestWebUIControllerFactory factory_;
 };
 
 class TestWebContentsObserver : public WebContentsObserver {
  public:
   explicit TestWebContentsObserver(WebContents* contents)
       : WebContentsObserver(contents) {
   }
-  virtual ~TestWebContentsObserver() {}
+  ~TestWebContentsObserver() override {}
 
-  virtual void DidFinishLoad(RenderFrameHost* render_frame_host,
-                             const GURL& validated_url) override {
+  void DidFinishLoad(RenderFrameHost* render_frame_host,
+                     const GURL& validated_url) override {
     last_url_ = validated_url;
   }
-  virtual void DidFailLoad(RenderFrameHost* render_frame_host,
-                           const GURL& validated_url,
-                           int error_code,
-                           const base::string16& error_description) override {
+  void DidFailLoad(RenderFrameHost* render_frame_host,
+                   const GURL& validated_url,
+                   int error_code,
+                   const base::string16& error_description) override {
     last_url_ = validated_url;
   }
 
   const GURL& last_url() const { return last_url_; }
 
  private:
   GURL last_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebContentsObserver);
 };
 
 // Pretends to be a normal browser that receives toggles and transitions to/from
 // a fullscreened state.
 class FakeFullscreenDelegate : public WebContentsDelegate {
  public:
   FakeFullscreenDelegate() : fullscreened_contents_(NULL) {}
-  virtual ~FakeFullscreenDelegate() {}
+  ~FakeFullscreenDelegate() override {}
 
-  virtual void ToggleFullscreenModeForTab(WebContents* web_contents,
-                                          bool enter_fullscreen) override {
+  void ToggleFullscreenModeForTab(WebContents* web_contents,
+                                  bool enter_fullscreen) override {
     fullscreened_contents_ = enter_fullscreen ? web_contents : NULL;
   }
 
-  virtual bool IsFullscreenForTabOrPending(const WebContents* web_contents)
-      const override {
+  bool IsFullscreenForTabOrPending(
+      const WebContents* web_contents) const override {
     return fullscreened_contents_ && web_contents == fullscreened_contents_;
   }
 
  private:
   WebContents* fullscreened_contents_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeFullscreenDelegate);
 };
 
 class FakeValidationMessageDelegate : public WebContentsDelegate {
  public:
   FakeValidationMessageDelegate()
       : hide_validation_message_was_called_(false) {}
-  virtual ~FakeValidationMessageDelegate() {}
+  ~FakeValidationMessageDelegate() override {}
 
-  virtual void HideValidationMessage(WebContents* web_contents) override {
+  void HideValidationMessage(WebContents* web_contents) override {
     hide_validation_message_was_called_ = true;
   }
 
   bool hide_validation_message_was_called() const {
     return hide_validation_message_was_called_;
   }
 
  private:
   bool hide_validation_message_was_called_;
 
@@ skipping 2110 matching lines @@
     int count = contents_zoom_changed_call_count_;
     contents_zoom_changed_call_count_ = 0;
     return count;
   }
 
   bool last_zoom_in() const {
     return last_zoom_in_;
   }
 
   // WebContentsDelegate:
-  virtual void ContentsZoomChange(bool zoom_in) override {
+  void ContentsZoomChange(bool zoom_in) override {
     contents_zoom_changed_call_count_++;
     last_zoom_in_ = zoom_in;
   }
 
  private:
   int contents_zoom_changed_call_count_;
   bool last_zoom_in_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentsZoomChangedDelegate);
 };
@@ skipping 322 matching lines @@
 
   // Destroy the remote player. No power save blockers should remain.
   rfh->OnMessageReceived(
       FrameHostMsg_MediaPausedNotification(0, kPlayerRemoteId));
   EXPECT_FALSE(contents()->has_video_power_save_blocker_for_testing());
   EXPECT_FALSE(contents()->has_audio_power_save_blocker_for_testing());
 }
 #endif
 
 }  // namespace content