replace OVERRIDE and FINAL with override and final in extensions/

extensions/browser/extension_function.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 "extensions/browser/extension_function.h"
 
 #include "base/logging.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 33 matching lines @@
     } else {
       function->SetResultList(result.Pass());
     }
     // It would be nice to DCHECK(error.empty()) but some legacy extension
     // function implementations... I'm looking at chrome.input.ime... do this
     // for some reason.
   }
 
   virtual ~ArgumentListResponseValue() {}
 
-  virtual bool Apply() OVERRIDE { return true; }
+  virtual bool Apply() override { return true; }
 
  private:
   std::string function_name_;
   const char* title_;
 };
 
 class ErrorResponseValue : public ExtensionFunction::ResponseValueObject {
  public:
   ErrorResponseValue(ExtensionFunction* function, const std::string& error) {
     // It would be nice to DCHECK(!error.empty()) but too many legacy extension
     // function implementations don't set error but signal failure.
     function->SetError(error);
   }
 
   virtual ~ErrorResponseValue() {}
 
-  virtual bool Apply() OVERRIDE { return false; }
+  virtual bool Apply() override { return false; }
 };
 
 class BadMessageResponseValue : public ExtensionFunction::ResponseValueObject {
  public:
   explicit BadMessageResponseValue(ExtensionFunction* function) {
     function->set_bad_message(true);
     NOTREACHED() << function->name() << ": bad message";
   }
 
   virtual ~BadMessageResponseValue() {}
 
-  virtual bool Apply() OVERRIDE { return false; }
+  virtual bool Apply() override { return false; }
 };
 
 class RespondNowAction : public ExtensionFunction::ResponseActionObject {
  public:
   typedef base::Callback<void(bool)> SendResponseCallback;
   RespondNowAction(ExtensionFunction::ResponseValue result,
                    const SendResponseCallback& send_response)
       : result_(result.Pass()), send_response_(send_response) {}
   virtual ~RespondNowAction() {}
 
-  virtual void Execute() OVERRIDE { send_response_.Run(result_->Apply()); }
+  virtual void Execute() override { send_response_.Run(result_->Apply()); }
 
  private:
   ExtensionFunction::ResponseValue result_;
   SendResponseCallback send_response_;
 };
 
 class RespondLaterAction : public ExtensionFunction::ResponseActionObject {
  public:
   virtual ~RespondLaterAction() {}
 
-  virtual void Execute() OVERRIDE {}
+  virtual void Execute() override {}
 };
 
 }  // namespace
 
 // static
 void ExtensionFunctionDeleteTraits::Destruct(const ExtensionFunction* x) {
   x->Destruct();
 }
 
 // Helper class to track the lifetime of ExtensionFunction's RenderViewHost or
 // RenderFrameHost  pointer and NULL it out when it dies. It also allows us to
 // filter IPC messages coming from the RenderViewHost/RenderFrameHost.
 class UIThreadExtensionFunction::RenderHostTracker
     : public content::WebContentsObserver {
  public:
   explicit RenderHostTracker(UIThreadExtensionFunction* function)
       : content::WebContentsObserver(
             function->render_view_host() ?
                 WebContents::FromRenderViewHost(function->render_view_host()) :
                 WebContents::FromRenderFrameHost(
                     function->render_frame_host())),
         function_(function) {
   }
 
  private:
   // content::WebContentsObserver:
   virtual void RenderViewDeleted(
-      content::RenderViewHost* render_view_host) OVERRIDE {
+      content::RenderViewHost* render_view_host) override {
     if (render_view_host != function_->render_view_host())
       return;
 
     function_->SetRenderViewHost(NULL);
   }
   virtual void RenderFrameDeleted(
-      content::RenderFrameHost* render_frame_host) OVERRIDE {
+      content::RenderFrameHost* render_frame_host) override {
     if (render_frame_host != function_->render_frame_host())
       return;
 
     function_->SetRenderFrameHost(NULL);
   }
 
   virtual bool OnMessageReceived(
       const IPC::Message& message,
-      content::RenderFrameHost* render_frame_host) OVERRIDE {
+      content::RenderFrameHost* render_frame_host) override {
     DCHECK(render_frame_host);
     if (render_frame_host == function_->render_frame_host())
       return function_->OnMessageReceived(message);
     else
       return false;
   }
 
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+  virtual bool OnMessageReceived(const IPC::Message& message) override {
     return function_->OnMessageReceived(message);
   }
 
   UIThreadExtensionFunction* function_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderHostTracker);
 };
 
 ExtensionFunction::ExtensionFunction()
     : request_id_(-1),
@@ skipping 313 matching lines @@
 
 ExtensionFunction::ResponseAction SyncIOThreadExtensionFunction::Run() {
   return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_));
 }
 
 // static
 bool SyncIOThreadExtensionFunction::ValidationFailure(
     SyncIOThreadExtensionFunction* function) {
   return false;
 }