replace OVERRIDE and FINAL with override and final in chrome/browser/[a-i]*

chrome/browser/custom_handlers/protocol_handler_registry.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_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_
 #define CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 33 matching lines @@
   // are changed.
   class DefaultClientObserver
       : public ShellIntegration::DefaultWebClientObserver {
    public:
     explicit DefaultClientObserver(ProtocolHandlerRegistry* registry);
     virtual ~DefaultClientObserver();
 
     // Get response from the worker regarding whether Chrome is the default
     // handler for the protocol.
     virtual void SetDefaultWebClientUIState(
-        ShellIntegration::DefaultWebClientUIState state) OVERRIDE;
+        ShellIntegration::DefaultWebClientUIState state) override;
 
-    virtual bool IsInteractiveSetDefaultPermitted() OVERRIDE;
+    virtual bool IsInteractiveSetDefaultPermitted() override;
 
     // Give the observer a handle to the worker, so we can find out the protocol
     // when we're called and also tell the worker if we get deleted.
     void SetWorker(ShellIntegration::DefaultProtocolClientWorker* worker);
 
    protected:
     ShellIntegration::DefaultProtocolClientWorker* worker_;
 
    private:
-    virtual bool IsOwnedByWorker() OVERRIDE;
+    virtual bool IsOwnedByWorker() override;
 
     // This is a raw pointer, not reference counted, intentionally. In general
     // subclasses of DefaultWebClientObserver are not able to be refcounted
     // e.g. the browser options page
     ProtocolHandlerRegistry* registry_;
 
     DISALLOW_COPY_AND_ASSIGN(DefaultClientObserver);
   };
 
   // |Delegate| provides an interface for interacting asynchronously
@@ skipping 31 matching lines @@
     virtual ~JobInterceptorFactory();
 
     // |job_factory| is set as the URLRequestJobFactory where requests are
     // forwarded if JobInterceptorFactory decides to pass on them.
     void Chain(scoped_ptr<net::URLRequestJobFactory> job_factory);
 
     // URLRequestJobFactory implementation.
     virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
         const std::string& scheme,
         net::URLRequest* request,
-        net::NetworkDelegate* network_delegate) const OVERRIDE;
-    virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE;
-    virtual bool IsHandledURL(const GURL& url) const OVERRIDE;
-    virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+        net::NetworkDelegate* network_delegate) const override;
+    virtual bool IsHandledProtocol(const std::string& scheme) const override;
+    virtual bool IsHandledURL(const GURL& url) const override;
+    virtual bool IsSafeRedirectTarget(const GURL& location) const override;
 
    private:
     // When JobInterceptorFactory decides to pass on particular requests,
     // they're forwarded to the chained URLRequestJobFactory, |job_factory_|.
     scoped_ptr<URLRequestJobFactory> job_factory_;
     // |io_thread_delegate_| performs the actual job creation decisions by
     // mirroring the ProtocolHandlerRegistry on the IO thread.
     scoped_refptr<IOThreadDelegate> io_thread_delegate_;
 
     DISALLOW_COPY_AND_ASSIGN(JobInterceptorFactory);
@@ skipping 105 matching lines @@
   // Puts this registry in the enabled state - registered protocol handlers
   // will handle requests.
   void Enable();
 
   // Puts this registry in the disabled state - registered protocol handlers
   // will not handle requests.
   void Disable();
 
   // This is called by the UI thread when the system is shutting down. This
   // does finalization which must be done on the UI thread.
-  virtual void Shutdown() OVERRIDE;
+  virtual void Shutdown() override;
 
   // Registers the preferences that we store registered protocol handlers in.
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
   bool enabled() const { return enabled_; }
 
   // Add a predefined protocol handler. This has to be called before the first
   // load command was issued, otherwise the command will be ignored.
   void AddPredefinedHandler(const ProtocolHandler& handler);
 
@@ skipping 118 matching lines @@
 
   // Copy of registry data for use on the IO thread. Changes to the registry
   // are posted to the IO thread where updates are applied to this object.
   scoped_refptr<IOThreadDelegate> io_thread_delegate_;
 
   DefaultClientObserverList default_client_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ProtocolHandlerRegistry);
 };
 #endif  // CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_