replace OVERRIDE and FINAL with override and final in chrome/browser/extensions/

chrome/browser/extensions/api/processes/processes_api.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_PROCESSES_PROCESSES_API_H__
 #define CHROME_BROWSER_EXTENSIONS_API_PROCESSES_PROCESSES_API_H__
 
 #include <set>
 #include <string>
 
@@ skipping 35 matching lines @@
   // out to the Task Manager to start listening for notifications. Returns
   // true if this was the first call and false if this has already been called.
   void StartTaskManagerListening();
 
   bool is_task_manager_listening() { return task_manager_listening_; }
 
  private:
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
+                       const content::NotificationDetails& details) override;
 
   // TaskManagerModelObserver methods.
-  virtual void OnItemsAdded(int start, int length) OVERRIDE;
-  virtual void OnModelChanged() OVERRIDE {}
-  virtual void OnItemsChanged(int start, int length) OVERRIDE;
-  virtual void OnItemsRemoved(int start, int length) OVERRIDE {}
-  virtual void OnItemsToBeRemoved(int start, int length) OVERRIDE;
+  virtual void OnItemsAdded(int start, int length) override;
+  virtual void OnModelChanged() override {}
+  virtual void OnItemsChanged(int start, int length) override;
+  virtual void OnItemsRemoved(int start, int length) override {}
+  virtual void OnItemsToBeRemoved(int start, int length) override;
 
   // Internal helpers for processing notifications.
   void ProcessHangEvent(content::RenderWidgetHost* widget);
   void ProcessClosedEvent(
       content::RenderProcessHost* rph,
       content::RenderProcessHost::RendererClosedDetails* details);
 
   void DispatchEvent(const std::string& event_name,
                      scoped_ptr<base::ListValue> event_args);
 
@@ skipping 20 matching lines @@
 };
 
 // The profile-keyed service that manages the processes extension API.
 class ProcessesAPI : public BrowserContextKeyedAPI,
                      public EventRouter::Observer {
  public:
   explicit ProcessesAPI(content::BrowserContext* context);
   virtual ~ProcessesAPI();
 
   // KeyedService implementation.
-  virtual void Shutdown() OVERRIDE;
+  virtual void Shutdown() override;
 
   // BrowserContextKeyedAPI implementation.
   static BrowserContextKeyedAPIFactory<ProcessesAPI>* GetFactoryInstance();
 
   // Convenience method to get the ProcessesAPI for a profile.
   static ProcessesAPI* Get(content::BrowserContext* context);
 
   ProcessesEventRouter* processes_event_router();
 
   // EventRouter::Observer implementation.
-  virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;
-  virtual void OnListenerRemoved(const EventListenerInfo& details) OVERRIDE;
+  virtual void OnListenerAdded(const EventListenerInfo& details) override;
+  virtual void OnListenerRemoved(const EventListenerInfo& details) override;
 
  private:
   friend class BrowserContextKeyedAPIFactory<ProcessesAPI>;
 
   content::BrowserContext* browser_context_;
 
   // BrowserContextKeyedAPI implementation.
   static const char* service_name() {
     return "ProcessesAPI";
   }
   static const bool kServiceRedirectedInIncognito = true;
   static const bool kServiceIsNULLWhileTesting = true;
 
   // Created lazily on first access.
   scoped_ptr<ProcessesEventRouter> processes_event_router_;
 };
 
 // This extension function returns the Process object for the renderer process
 // currently in use by the specified Tab.
 class GetProcessIdForTabFunction : public ChromeAsyncExtensionFunction {
  public:
   GetProcessIdForTabFunction();
 
  private:
   virtual ~GetProcessIdForTabFunction() {}
-  virtual bool RunAsync() OVERRIDE;
+  virtual bool RunAsync() override;
 
   void GetProcessIdForTab();
 
   // Storage for the tab ID parameter.
   int tab_id_;
 
   DECLARE_EXTENSION_FUNCTION("processes.getProcessIdForTab",
                              PROCESSES_GETPROCESSIDFORTAB)
 };
 
 // Extension function that allows terminating Chrome subprocesses, by supplying
 // the unique ID for the process coming from the ChildProcess ID pool.
 // Using unique IDs instead of OS process IDs allows two advantages:
 // * guaranteed uniqueness, since OS process IDs can be reused
 // * guards against killing non-Chrome processes
 class TerminateFunction : public ChromeAsyncExtensionFunction {
  public:
   TerminateFunction();
 
  private:
   virtual ~TerminateFunction() {}
-  virtual bool RunAsync() OVERRIDE;
+  virtual bool RunAsync() override;
 
   void TerminateProcess();
 
   // Storage for the process ID parameter.
   int process_id_;
 
   DECLARE_EXTENSION_FUNCTION("processes.terminate",
                              PROCESSES_TERMINATE)
 };
 
 // Extension function which returns a set of Process objects, containing the
 // details corresponding to the process IDs supplied as input.
 class GetProcessInfoFunction : public ChromeAsyncExtensionFunction {
  public:
   GetProcessInfoFunction();
 
  private:
   virtual ~GetProcessInfoFunction();
-  virtual bool RunAsync() OVERRIDE;
+  virtual bool RunAsync() override;
 
   void GatherProcessInfo();
 
   // Member variables to store the function parameters
   std::vector<int> process_ids_;
 #if defined(ENABLE_TASK_MANAGER)
   bool memory_;
 #endif
 
   DECLARE_EXTENSION_FUNCTION("processes.getProcessInfo",
                              PROCESSES_GETPROCESSINFO)
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_PROCESSES_PROCESSES_API_H__