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

content/browser/frame_host/render_frame_host_manager_unittest.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 "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "content/browser/frame_host/cross_site_transferring_request.h"
@@ skipping 33 matching lines @@
 
 namespace content {
 namespace {
 
 class RenderFrameHostManagerTestWebUIControllerFactory
     : public WebUIControllerFactory {
  public:
   RenderFrameHostManagerTestWebUIControllerFactory()
     : should_create_webui_(false) {
   }
-  virtual ~RenderFrameHostManagerTestWebUIControllerFactory() {}
+  ~RenderFrameHostManagerTestWebUIControllerFactory() override {}
 
   void set_should_create_webui(bool should_create_webui) {
     should_create_webui_ = should_create_webui;
   }
 
   // WebUIFactory implementation.
-  virtual WebUIController* CreateWebUIControllerForURL(
-      WebUI* web_ui, const GURL& url) const override {
+  WebUIController* CreateWebUIControllerForURL(WebUI* web_ui,
+                                               const GURL& url) const override {
     if (!(should_create_webui_ && HasWebUIScheme(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 HasWebUIScheme(url);
+  }
+
+  bool UseWebUIBindingsForURL(BrowserContext* browser_context,
                               const GURL& url) const override {
     return HasWebUIScheme(url);
   }
 
-  virtual bool UseWebUIBindingsForURL(BrowserContext* browser_context,
-                                      const GURL& url) const override {
-    return HasWebUIScheme(url);
-  }
-
  private:
   bool should_create_webui_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostManagerTestWebUIControllerFactory);
 };
 
 class BeforeUnloadFiredWebContentsDelegate : public WebContentsDelegate {
  public:
   BeforeUnloadFiredWebContentsDelegate() {}
-  virtual ~BeforeUnloadFiredWebContentsDelegate() {}
+  ~BeforeUnloadFiredWebContentsDelegate() override {}
 
-  virtual void BeforeUnloadFired(WebContents* web_contents,
-                                 bool proceed,
-                                 bool* proceed_to_fire_unload) override {
+  void BeforeUnloadFired(WebContents* web_contents,
+                         bool proceed,
+                         bool* proceed_to_fire_unload) override {
     *proceed_to_fire_unload = proceed;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BeforeUnloadFiredWebContentsDelegate);
 };
 
 class CloseWebContentsDelegate : public WebContentsDelegate {
  public:
   CloseWebContentsDelegate() : close_called_(false) {}
-  virtual ~CloseWebContentsDelegate() {}
+  ~CloseWebContentsDelegate() override {}
 
-  virtual void CloseContents(WebContents* web_contents) override {
+  void CloseContents(WebContents* web_contents) override {
     close_called_ = true;
   }
 
   bool is_closed() { return close_called_; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloseWebContentsDelegate);
 
   bool close_called_;
 };
 
 // This observer keeps track of the last deleted RenderViewHost to avoid
 // accessing it and causing use-after-free condition.
 class RenderViewHostDeletedObserver : public WebContentsObserver {
  public:
   RenderViewHostDeletedObserver(RenderViewHost* rvh)
       : WebContentsObserver(WebContents::FromRenderViewHost(rvh)),
         process_id_(rvh->GetProcess()->GetID()),
         routing_id_(rvh->GetRoutingID()),
         deleted_(false) {
   }
 
-  virtual void RenderViewDeleted(RenderViewHost* render_view_host) override {
+  void RenderViewDeleted(RenderViewHost* render_view_host) override {
     if (render_view_host->GetProcess()->GetID() == process_id_ &&
         render_view_host->GetRoutingID() == routing_id_) {
       deleted_ = true;
     }
   }
 
   bool deleted() {
     return deleted_;
   }
 
  private:
   int process_id_;
   int routing_id_;
   bool deleted_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostDeletedObserver);
 };
 
 // This observer keeps track of the last created RenderFrameHost to allow tests
 // to ensure that no RenderFrameHost objects are created when not expected.
 class RenderFrameHostCreatedObserver : public WebContentsObserver {
  public:
   RenderFrameHostCreatedObserver(WebContents* web_contents)
       : WebContentsObserver(web_contents),
         created_(false) {
   }
 
-  virtual void RenderFrameCreated(RenderFrameHost* render_frame_host) override {
+  void RenderFrameCreated(RenderFrameHost* render_frame_host) override {
     created_ = true;
   }
 
   bool created() {
     return created_;
   }
 
  private:
   bool created_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostCreatedObserver);
 };
 
 // This observer keeps track of the last deleted RenderFrameHost to avoid
 // accessing it and causing use-after-free condition.
 class RenderFrameHostDeletedObserver : public WebContentsObserver {
  public:
   RenderFrameHostDeletedObserver(RenderFrameHost* rfh)
       : WebContentsObserver(WebContents::FromRenderFrameHost(rfh)),
         process_id_(rfh->GetProcess()->GetID()),
         routing_id_(rfh->GetRoutingID()),
         deleted_(false) {
   }
 
-  virtual void RenderFrameDeleted(RenderFrameHost* render_frame_host) override {
+  void RenderFrameDeleted(RenderFrameHost* render_frame_host) override {
     if (render_frame_host->GetProcess()->GetID() == process_id_ &&
         render_frame_host->GetRoutingID() == routing_id_) {
       deleted_ = true;
     }
   }
 
   bool deleted() {
     return deleted_;
   }
 
@@ skipping 10 matching lines @@
 // update events, which the FilterMessagesWhileSwappedOut test simulates being
 // sent. The test is successful if the event is not observed.
 // See http://crbug.com/351815
 class PluginFaviconMessageObserver : public WebContentsObserver {
  public:
   PluginFaviconMessageObserver(WebContents* web_contents)
       : WebContentsObserver(web_contents),
         plugin_crashed_(false),
         favicon_received_(false) { }
 
-  virtual void PluginCrashed(const base::FilePath& plugin_path,
-                             base::ProcessId plugin_pid) override {
+  void PluginCrashed(const base::FilePath& plugin_path,
+                     base::ProcessId plugin_pid) override {
     plugin_crashed_ = true;
   }
 
-  virtual void DidUpdateFaviconURL(
-      const std::vector<FaviconURL>& candidates) override {
+  void DidUpdateFaviconURL(const std::vector<FaviconURL>& candidates) override {
     favicon_received_ = true;
   }
 
   bool plugin_crashed() {
     return plugin_crashed_;
   }
 
   bool favicon_received() {
     return favicon_received_;
   }
 
  private:
   bool plugin_crashed_;
   bool favicon_received_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginFaviconMessageObserver);
 };
 
 // Ensures that RenderFrameDeleted and RenderFrameCreated are called in a
 // consistent manner.
 class FrameLifetimeConsistencyChecker : public WebContentsObserver {
  public:
   explicit FrameLifetimeConsistencyChecker(WebContentsImpl* web_contents)
       : WebContentsObserver(web_contents) {
     RenderViewCreated(web_contents->GetRenderViewHost());
     RenderFrameCreated(web_contents->GetMainFrame());
   }
 
-  virtual void RenderFrameCreated(RenderFrameHost* render_frame_host) override {
+  void RenderFrameCreated(RenderFrameHost* render_frame_host) override {
     std::pair<int, int> routing_pair =
         std::make_pair(render_frame_host->GetProcess()->GetID(),
                        render_frame_host->GetRoutingID());
     bool was_live_already = !live_routes_.insert(routing_pair).second;
     bool was_used_before = deleted_routes_.count(routing_pair) != 0;
 
     if (was_live_already) {
       FAIL() << "RenderFrameCreated called more than once for routing pair: "
              << Format(render_frame_host);
     } else if (was_used_before) {
       FAIL() << "RenderFrameCreated called for routing pair "
              << Format(render_frame_host) << " that was previously deleted.";
     }
   }
 
-  virtual void RenderFrameDeleted(RenderFrameHost* render_frame_host) override {
+  void RenderFrameDeleted(RenderFrameHost* render_frame_host) override {
     std::pair<int, int> routing_pair =
         std::make_pair(render_frame_host->GetProcess()->GetID(),
                        render_frame_host->GetRoutingID());
     bool was_live = live_routes_.erase(routing_pair);
     bool was_dead_already = !deleted_routes_.insert(routing_pair).second;
 
     if (was_dead_already) {
       FAIL() << "RenderFrameDeleted called more than once for routing pair "
              << Format(render_frame_host);
     } else if (!was_live) {
@@ skipping 465 matching lines @@
 // next test cases to detect the bug mentioned at
 // http://crbug.com/259859.
 class RenderViewHostDestroyer : public WebContentsObserver {
  public:
   RenderViewHostDestroyer(RenderViewHost* render_view_host,
                           WebContents* web_contents)
       : WebContentsObserver(WebContents::FromRenderViewHost(render_view_host)),
         render_view_host_(render_view_host),
         web_contents_(web_contents) {}
 
-  virtual void RenderViewDeleted(
-      RenderViewHost* render_view_host) override {
+  void RenderViewDeleted(RenderViewHost* render_view_host) override {
     if (render_view_host == render_view_host_)
       delete web_contents_;
   }
 
  private:
   RenderViewHost* render_view_host_;
   WebContents* web_contents_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostDestroyer);
 };
@@ skipping 1033 matching lines @@
    pending_rfh->GetSiteInstance()->increment_active_frame_count();
 
     contents()->GetMainFrame()->OnMessageReceived(
         FrameHostMsg_BeforeUnload_ACK(0, false, now, now));
     EXPECT_FALSE(contents()->cross_navigation_pending());
     EXPECT_FALSE(rfh_deleted_observer.deleted());
   }
 }
 
 }  // namespace content