replace OVERRIDE and FINAL with override and 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 {
+    virtual void WillStartRequest(bool* defer) override {
       *defer = true;
     }
 
-    virtual const char* GetNameForLogging() const OVERRIDE {
+    virtual 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 23 matching lines @@
         rvh_(NULL) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_TAB_ADDED,
                    content::NotificationService::AllSources());
     test_navigation_listener_->DelayRequestsForURL(delay_url_);
   }
   virtual ~DelayLoadStartAndExecuteJavascript() {}
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       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(
       content::RenderFrameHost* render_frame_host,
       const GURL& validated_url,
       bool is_error_page,
-      bool is_iframe_srcdoc) OVERRIDE {
+      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(
       content::RenderFrameHost* render_frame_host,
       const GURL& url,
-      ui::PageTransition transition_type) OVERRIDE {
+      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();
   }
 
  private:
   content::NotificationRegistrar registrar_;
 
@@ skipping 18 matching lines @@
       : ChromeResourceDispatcherHostDelegate(prerender_tracker),
         test_navigation_listener_(test_navigation_listener) {
   }
   virtual ~TestResourceDispatcherHostDelegate() {}
 
   virtual void RequestBeginning(
       net::URLRequest* request,
       content::ResourceContext* resource_context,
       content::AppCacheService* appcache_service,
       ResourceType resource_type,
-      ScopedVector<content::ResourceThrottle>* throttles) OVERRIDE {
+      ScopedVector<content::ResourceThrottle>* throttles) override {
     ChromeResourceDispatcherHostDelegate::RequestBeginning(
         request,
         resource_context,
         appcache_service,
         resource_type,
         throttles);
     content::ResourceThrottle* throttle =
         test_navigation_listener_->CreateResourceThrottle(request->url(),
                                                           resource_type);
     if (throttle)
       throttles->push_back(throttle);
   }
 
  private:
   scoped_refptr<TestNavigationListener> test_navigation_listener_;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcherHostDelegate);
 };
 
 }  // namespace
 
 class WebNavigationApiTest : public ExtensionApiTest {
  public:
   WebNavigationApiTest() {}
   virtual ~WebNavigationApiTest() {}
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual 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 {
+  virtual 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