replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/prerender/prerender_contents.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 "chrome/browser/prerender/prerender_contents.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
@@ skipping 84 matching lines @@
     (1 << INTERNAL_COOKIE_EVENT_MAX);
 
 // static
 const int PrerenderContents::kNumCookieSendTypes = COOKIE_SEND_TYPE_MAX;
 
 class PrerenderContentsFactoryImpl : public PrerenderContents::Factory {
  public:
   virtual PrerenderContents* CreatePrerenderContents(
       PrerenderManager* prerender_manager, Profile* profile,
       const GURL& url, const content::Referrer& referrer,
-      Origin origin, uint8 experiment_id) OVERRIDE {
+      Origin origin, uint8 experiment_id) override {
     return new PrerenderContents(prerender_manager, profile,
                                  url, referrer, origin, experiment_id);
   }
 };
 
 // WebContentsDelegateImpl -----------------------------------------------------
 
 class PrerenderContents::WebContentsDelegateImpl
     : public content::WebContentsDelegate {
  public:
   explicit WebContentsDelegateImpl(PrerenderContents* prerender_contents)
       : prerender_contents_(prerender_contents) {
   }
 
   // content::WebContentsDelegate implementation:
   virtual WebContents* OpenURLFromTab(WebContents* source,
-                                      const OpenURLParams& params) OVERRIDE {
+                                      const OpenURLParams& params) override {
     // |OpenURLFromTab| is typically called when a frame performs a navigation
     // that requires the browser to perform the transition instead of WebKit.
     // Examples include prerendering a site that redirects to an app URL,
     // or if --enable-strict-site-isolation is specified and the prerendered
     // frame redirects to a different origin.
     // TODO(cbentzel): Consider supporting this if it is a common case during
     // prerenders.
     prerender_contents_->Destroy(FINAL_STATUS_OPEN_URL);
     return NULL;
   }
 
-  virtual void CloseContents(content::WebContents* contents) OVERRIDE {
+  virtual void CloseContents(content::WebContents* contents) override {
     prerender_contents_->Destroy(FINAL_STATUS_CLOSED);
   }
 
   virtual void CanDownload(
       RenderViewHost* render_view_host,
       const GURL& url,
       const std::string& request_method,
-      const base::Callback<void(bool)>& callback) OVERRIDE {
+      const base::Callback<void(bool)>& callback) override {
     prerender_contents_->Destroy(FINAL_STATUS_DOWNLOAD);
     // Cancel the download.
     callback.Run(false);
   }
 
    virtual bool ShouldCreateWebContents(
        WebContents* web_contents,
        int route_id,
        WindowContainerType window_container_type,
        const base::string16& frame_name,
        const GURL& target_url,
        const std::string& partition_id,
-       SessionStorageNamespace* session_storage_namespace) OVERRIDE {
+       SessionStorageNamespace* session_storage_namespace) override {
     // Since we don't want to permit child windows that would have a
     // window.opener property, terminate prerendering.
     prerender_contents_->Destroy(FINAL_STATUS_CREATE_NEW_WINDOW);
     // Cancel the popup.
     return false;
   }
 
-  virtual bool OnGoToEntryOffset(int offset) OVERRIDE {
+  virtual bool OnGoToEntryOffset(int offset) override {
     // This isn't allowed because the history merge operation
     // does not work if there are renderer issued challenges.
     // TODO(cbentzel): Cancel in this case? May not need to do
     // since render-issued offset navigations are not guaranteed,
     // but indicates that the page cares about the history.
     return false;
   }
 
-  virtual bool ShouldSuppressDialogs() OVERRIDE {
+  virtual bool ShouldSuppressDialogs() override {
     // We still want to show the user the message when they navigate to this
     // page, so cancel this prerender.
     prerender_contents_->Destroy(FINAL_STATUS_JAVASCRIPT_ALERT);
     // Always suppress JavaScript messages if they're triggered by a page being
     // prerendered.
     return true;
   }
 
   virtual void RegisterProtocolHandler(WebContents* web_contents,
                                        const std::string& protocol,
                                        const GURL& url,
-                                       bool user_gesture) OVERRIDE {
+                                       bool user_gesture) override {
     // TODO(mmenke): Consider supporting this if it is a common case during
     // prerenders.
     prerender_contents_->Destroy(FINAL_STATUS_REGISTER_PROTOCOL_HANDLER);
   }
 
   virtual gfx::Size GetSizeForNewRenderView(
-      WebContents* web_contents) const OVERRIDE {
+      WebContents* web_contents) const override {
     // Have to set the size of the RenderView on initialization to be sure it is
     // set before the RenderView is hidden on all platforms (esp. Android).
     return prerender_contents_->size_;
   }
 
  private:
   PrerenderContents* prerender_contents_;
 };
 
 void PrerenderContents::Observer::OnPrerenderStopLoading(
@@ skipping 684 matching lines @@
  void PrerenderContents::AddResourceThrottle(
      const base::WeakPtr<PrerenderResourceThrottle>& throttle) {
    resource_throttles_.push_back(throttle);
  }
 
  void PrerenderContents::AddNetworkBytes(int64 bytes) {
    network_bytes_ += bytes;
  }
 
 }  // namespace prerender