Standardize usage of virtual/override/final in chrome/browser/

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 28 matching lines @@
   enum HandlerSource {
     USER,    // The handler was installed by user
     POLICY,  // The handler was installed by policy
   };
   // Provides notification of when the OS level user agent settings
   // are changed.
   class DefaultClientObserver
       : public ShellIntegration::DefaultWebClientObserver {
    public:
     explicit DefaultClientObserver(ProtocolHandlerRegistry* registry);
-    virtual ~DefaultClientObserver();
+    ~DefaultClientObserver() override;
 
     // Get response from the worker regarding whether Chrome is the default
     // handler for the protocol.
-    virtual void SetDefaultWebClientUIState(
+    void SetDefaultWebClientUIState(
         ShellIntegration::DefaultWebClientUIState state) override;
 
-    virtual bool IsInteractiveSetDefaultPermitted() override;
+    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;
+    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 21 matching lines @@
   // JobInterceptorFactory intercepts URLRequestJob creation for URLRequests the
   // ProtocolHandlerRegistry is registered to handle.  When no handler is
   // registered, the URLRequest is passed along to the chained
   // URLRequestJobFactory (set with |JobInterceptorFactory::Chain|).
   // JobInterceptorFactory's are created via
   // |ProtocolHandlerRegistry::CreateJobInterceptorFactory|.
   class JobInterceptorFactory : public net::URLRequestJobFactory {
    public:
     // |io_thread_delegate| is used to perform actual job creation work.
     explicit JobInterceptorFactory(IOThreadDelegate* io_thread_delegate);
-    virtual ~JobInterceptorFactory();
+    ~JobInterceptorFactory() override;
 
     // |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(
+    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;
+    bool IsHandledProtocol(const std::string& scheme) const override;
+    bool IsHandledURL(const GURL& url) const override;
+    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);
   };
 
   typedef std::map<std::string, ProtocolHandler> ProtocolHandlerMap;
   typedef std::vector<ProtocolHandler> ProtocolHandlerList;
   typedef std::map<std::string, ProtocolHandlerList> ProtocolHandlerMultiMap;
   typedef std::vector<DefaultClientObserver*> DefaultClientObserverList;
 
   // Creates a new instance. Assumes ownership of |delegate|.
   ProtocolHandlerRegistry(content::BrowserContext* context, Delegate* delegate);
-  virtual ~ProtocolHandlerRegistry();
+  ~ProtocolHandlerRegistry() override;
 
   // Returns a net::URLRequestJobFactory suitable for use on the IO thread, but
   // is initialized on the UI thread.
   scoped_ptr<JobInterceptorFactory> CreateJobInterceptorFactory();
 
   // Called when a site tries to register as a protocol handler. If the request
   // can be handled silently by the registry - either to ignore the request
   // or to update an existing handler - the request will succeed. If this
   // function returns false the user needs to be prompted for confirmation.
   bool SilentlyHandleRegisterHandlerRequest(const ProtocolHandler& handler);
@@ skipping 85 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;
+  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_