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

chrome/browser/extensions/api/web_navigation/web_navigation_apitest.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 <list>
 #include <set>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 101 matching lines @@
 
   // Stores a throttle per URL request that we have delayed.
   class Throttle : public content::ResourceThrottle,
                    public base::SupportsWeakPtr<Throttle> {
    public:
     void Resume() {
       controller()->Resume();
     }
 
     // content::ResourceThrottle implementation.
-    virtual void WillStartRequest(bool* defer) override {
-      *defer = true;
-    }
+    void WillStartRequest(bool* defer) override { *defer = true; }
 
-    virtual const char* GetNameForLogging() const override {
+    const char* GetNameForLogging() const override {
       return "TestNavigationListener::Throttle";
     }
   };
   typedef base::WeakPtr<Throttle> WeakThrottle;
   typedef std::list<WeakThrottle> WeakThrottleList;
   WeakThrottleList throttles_;
 
   // The set of URLs to be delayed.
   std::set<GURL> urls_to_delay_;
 
@@ skipping 19 matching lines @@
         delay_url_(delay_url),
         until_url_suffix_(until_url_suffix),
         script_(script),
         script_was_executed_(false),
         rvh_(NULL) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_TAB_ADDED,
                    content::NotificationService::AllSources());
     test_navigation_listener_->DelayRequestsForURL(delay_url_);
   }
-  virtual ~DelayLoadStartAndExecuteJavascript() {}
+  ~DelayLoadStartAndExecuteJavascript() override {}
 
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override {
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override {
     if (type != chrome::NOTIFICATION_TAB_ADDED) {
       NOTREACHED();
       return;
     }
     content::WebContentsObserver::Observe(
         content::Details<content::WebContents>(details).ptr());
     registrar_.RemoveAll();
   }
 
-  virtual void DidStartProvisionalLoadForFrame(
+  void DidStartProvisionalLoadForFrame(
       content::RenderFrameHost* render_frame_host,
       const GURL& validated_url,
       bool is_error_page,
       bool is_iframe_srcdoc) override {
     if (validated_url != delay_url_ || !rvh_)
       return;
 
     rvh_->GetMainFrame()->ExecuteJavaScript(base::UTF8ToUTF16(script_));
     script_was_executed_ = true;
   }
 
-  virtual void DidCommitProvisionalLoadForFrame(
+  void DidCommitProvisionalLoadForFrame(
       content::RenderFrameHost* render_frame_host,
       const GURL& url,
       ui::PageTransition transition_type) override {
     if (script_was_executed_ && EndsWith(url.spec(), until_url_suffix_, true)) {
       content::WebContentsObserver::Observe(NULL);
       test_navigation_listener_->ResumeAll();
     }
     rvh_ = render_frame_host->GetRenderViewHost();
   }
 
@@ skipping 14 matching lines @@
 // A ResourceDispatcherHostDelegate that adds a TestNavigationObserver.
 class TestResourceDispatcherHostDelegate
     : public ChromeResourceDispatcherHostDelegate {
  public:
   TestResourceDispatcherHostDelegate(
       prerender::PrerenderTracker* prerender_tracker,
       TestNavigationListener* test_navigation_listener)
       : ChromeResourceDispatcherHostDelegate(prerender_tracker),
         test_navigation_listener_(test_navigation_listener) {
   }
-  virtual ~TestResourceDispatcherHostDelegate() {}
+  ~TestResourceDispatcherHostDelegate() override {}
 
-  virtual void RequestBeginning(
+  void RequestBeginning(
       net::URLRequest* request,
       content::ResourceContext* resource_context,
       content::AppCacheService* appcache_service,
       ResourceType resource_type,
       ScopedVector<content::ResourceThrottle>* throttles) override {
     ChromeResourceDispatcherHostDelegate::RequestBeginning(
         request,
         resource_context,
         appcache_service,
         resource_type,
@@ skipping 11 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcherHostDelegate);
 };
 
 }  // namespace
 
 class WebNavigationApiTest : public ExtensionApiTest {
  public:
   WebNavigationApiTest() {}
   virtual ~WebNavigationApiTest() {}
 
-  virtual void SetUpInProcessBrowserTestFixture() override {
+  void SetUpInProcessBrowserTestFixture() override {
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
 
     FrameNavigationState::set_allow_extension_scheme(true);
 
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kAllowLegacyExtensionManifests);
 
     host_resolver()->AddRule("*", "127.0.0.1");
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     ExtensionApiTest::SetUpOnMainThread();
     test_navigation_listener_ = new TestNavigationListener();
     resource_dispatcher_host_delegate_.reset(
         new TestResourceDispatcherHostDelegate(
             g_browser_process->prerender_tracker(),
             test_navigation_listener_.get()));
     content::ResourceDispatcherHost::Get()->SetDelegate(
         resource_dispatcher_host_delegate_.get());
   }
 
@@ skipping 345 matching lines @@
           "extensions/api_test/webnavigation/crash/b.html",
       embedded_test_server()->port()));
   ui_test_utils::NavigateToURL(browser(), url);
 
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 #endif
 
 }  // namespace extensions