Replacing the OVERRIDE with override and FINAL with final in content/browser/frame_host

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 41 matching lines @@
     : should_create_webui_(false) {
   }
   virtual ~RenderFrameHostManagerTestWebUIControllerFactory() {}
 
   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 {
+      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 {
+      const GURL& url) const override {
     return WebUI::kNoWebUI;
   }
 
   virtual bool UseWebUIForURL(BrowserContext* browser_context,
-                              const GURL& url) const OVERRIDE {
+                              const GURL& url) const override {
     return HasWebUIScheme(url);
   }
 
   virtual bool UseWebUIBindingsForURL(BrowserContext* browser_context,
-                                      const GURL& url) const OVERRIDE {
+                                      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() {}
 
   virtual void BeforeUnloadFired(WebContents* web_contents,
                                  bool proceed,
-                                 bool* proceed_to_fire_unload) OVERRIDE {
+                                 bool* proceed_to_fire_unload) override {
     *proceed_to_fire_unload = proceed;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BeforeUnloadFiredWebContentsDelegate);
 };
 
 // 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 {
+  virtual 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 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 {
+  virtual 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 12 matching lines @@
 // 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 {
+                             base::ProcessId plugin_pid) override {
     plugin_crashed_ = true;
   }
 
   virtual void DidUpdateFaviconURL(
-      const std::vector<FaviconURL>& candidates) OVERRIDE {
+      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 {
+  virtual 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 {
+  virtual 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 13 matching lines @@
   }
   std::set<std::pair<int, int> > live_routes_;
   std::set<std::pair<int, int> > deleted_routes_;
 };
 
 }  // namespace
 
 class RenderFrameHostManagerTest
     : public RenderViewHostImplTestHarness {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
     WebUIControllerFactory::RegisterFactory(&factory_);
     lifetime_checker_.reset(new FrameLifetimeConsistencyChecker(contents()));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     lifetime_checker_.reset();
     RenderViewHostImplTestHarness::TearDown();
     WebUIControllerFactory::UnregisterFactoryForTesting(&factory_);
   }
 
   void set_should_create_webui(bool should_create_webui) {
     factory_.set_should_create_webui(should_create_webui);
   }
 
   void NavigateActiveAndCommit(const GURL& url) {
@@ skipping 384 matching lines @@
 // 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 {
+      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 1008 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