replace OVERRIDE and FINAL with override and final in extensions/

extensions/browser/extension_function.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 #define EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 
 #include <list>
 #include <string>
 
@@ skipping 388 matching lines @@
   // A delegate for use in testing, to intercept the call to SendResponse.
   class DelegateForTests {
    public:
     virtual void OnSendResponse(UIThreadExtensionFunction* function,
                                 bool success,
                                 bool bad_message) = 0;
   };
 
   UIThreadExtensionFunction();
 
-  virtual UIThreadExtensionFunction* AsUIThreadExtensionFunction() OVERRIDE;
+  virtual UIThreadExtensionFunction* AsUIThreadExtensionFunction() override;
 
   void set_test_delegate(DelegateForTests* delegate) {
     delegate_ = delegate;
   }
 
   // Called when a message was received.
   // Should return true if it processed the message.
   virtual bool OnMessageReceived(const IPC::Message& message);
 
   // Set the browser context which contains the extension that has originated
@@ skipping 28 matching lines @@
   // Emits a message to the extension's devtools console.
   void WriteToConsole(content::ConsoleMessageLevel level,
                       const std::string& message);
 
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class base::DeleteHelper<UIThreadExtensionFunction>;
 
   virtual ~UIThreadExtensionFunction();
 
-  virtual void SendResponse(bool success) OVERRIDE;
+  virtual void SendResponse(bool success) override;
 
   // Sets the Blob UUIDs whose ownership is being transferred to the renderer.
   void SetTransferredBlobUUIDs(const std::vector<std::string>& blob_uuids);
 
   // The dispatcher that will service this extension function call.
   base::WeakPtr<extensions::ExtensionFunctionDispatcher> dispatcher_;
 
   // The RenderViewHost we will send responses to.
   content::RenderViewHost* render_view_host_;
 
   // The RenderFrameHost we will send responses to.
   // NOTE: either render_view_host_ or render_frame_host_ will be set, as we
   // port code to use RenderFrames for OOPIF. See http://crbug.com/304341.
   content::RenderFrameHost* render_frame_host_;
 
   // The content::BrowserContext of this function's extension.
   content::BrowserContext* context_;
 
  private:
   class RenderHostTracker;
 
-  virtual void Destruct() const OVERRIDE;
+  virtual void Destruct() const override;
 
   // TODO(tommycli): Remove once RenderViewHost is gone.
   IPC::Sender* GetIPCSender();
   int GetRoutingID();
 
   scoped_ptr<RenderHostTracker> tracker_;
 
   DelegateForTests* delegate_;
 
   // The blobs transferred to the renderer process.
   std::vector<std::string> transferred_blob_uuids_;
 };
 
 // Extension functions that run on the IO thread. This type of function avoids
 // a roundtrip to and from the UI thread (because communication with the
 // extension process happens on the IO thread). It's intended to be used when
 // performance is critical (e.g. the webRequest API which can block network
 // requests). Generally, UIThreadExtensionFunction is more appropriate and will
 // be easier to use and interface with the rest of the browser.
 class IOThreadExtensionFunction : public ExtensionFunction {
  public:
   IOThreadExtensionFunction();
 
-  virtual IOThreadExtensionFunction* AsIOThreadExtensionFunction() OVERRIDE;
+  virtual IOThreadExtensionFunction* AsIOThreadExtensionFunction() override;
 
   void set_ipc_sender(
       base::WeakPtr<extensions::ExtensionMessageFilter> ipc_sender,
       int routing_id) {
     ipc_sender_ = ipc_sender;
     routing_id_ = routing_id;
   }
 
   base::WeakPtr<extensions::ExtensionMessageFilter> ipc_sender_weak() const {
     return ipc_sender_;
   }
 
   int routing_id() const { return routing_id_; }
 
   void set_extension_info_map(const extensions::InfoMap* extension_info_map) {
     extension_info_map_ = extension_info_map;
   }
   const extensions::InfoMap* extension_info_map() const {
     return extension_info_map_.get();
   }
 
  protected:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::IO>;
   friend class base::DeleteHelper<IOThreadExtensionFunction>;
 
   virtual ~IOThreadExtensionFunction();
 
-  virtual void Destruct() const OVERRIDE;
+  virtual void Destruct() const override;
 
-  virtual void SendResponse(bool success) OVERRIDE;
+  virtual void SendResponse(bool success) override;
 
  private:
   base::WeakPtr<extensions::ExtensionMessageFilter> ipc_sender_;
   int routing_id_;
 
   scoped_refptr<const extensions::InfoMap> extension_info_map_;
 };
 
 // Base class for an extension function that runs asynchronously *relative to
 // the browser's UI thread*.
 class AsyncExtensionFunction : public UIThreadExtensionFunction {
  public:
   AsyncExtensionFunction();
 
  protected:
   virtual ~AsyncExtensionFunction();
 
   // Deprecated: Override UIThreadExtensionFunction and implement Run() instead.
   //
   // AsyncExtensionFunctions implement this method. Return true to indicate that
   // nothing has gone wrong yet; SendResponse must be called later. Return false
   // to respond immediately with an error.
   virtual bool RunAsync() = 0;
 
   // ValidationFailure override to match RunAsync().
   static bool ValidationFailure(AsyncExtensionFunction* function);
 
  private:
-  virtual ResponseAction Run() OVERRIDE;
+  virtual ResponseAction Run() override;
 };
 
 // A SyncExtensionFunction is an ExtensionFunction that runs synchronously
 // *relative to the browser's UI thread*. Note that this has nothing to do with
 // running synchronously relative to the extension process. From the extension
 // process's point of view, the function is still asynchronous.
 //
 // This kind of function is convenient for implementing simple APIs that just
 // need to interact with things on the browser UI thread.
 class SyncExtensionFunction : public UIThreadExtensionFunction {
  public:
   SyncExtensionFunction();
 
  protected:
   virtual ~SyncExtensionFunction();
 
   // Deprecated: Override UIThreadExtensionFunction and implement Run() instead.
   //
   // SyncExtensionFunctions implement this method. Return true to respond
   // immediately with success, false to respond immediately with an error.
   virtual bool RunSync() = 0;
 
   // ValidationFailure override to match RunSync().
   static bool ValidationFailure(SyncExtensionFunction* function);
 
  private:
-  virtual ResponseAction Run() OVERRIDE;
+  virtual ResponseAction Run() override;
 };
 
 class SyncIOThreadExtensionFunction : public IOThreadExtensionFunction {
  public:
   SyncIOThreadExtensionFunction();
 
  protected:
   virtual ~SyncIOThreadExtensionFunction();
 
   // Deprecated: Override IOThreadExtensionFunction and implement Run() instead.
   //
   // SyncIOThreadExtensionFunctions implement this method. Return true to
   // respond immediately with success, false to respond immediately with an
   // error.
   virtual bool RunSync() = 0;
 
   // ValidationFailure override to match RunSync().
   static bool ValidationFailure(SyncIOThreadExtensionFunction* function);
 
  private:
-  virtual ResponseAction Run() OVERRIDE;
+  virtual ResponseAction Run() override;
 };
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_