Convert ProtocolHandlerRegistry to be a ProfileKeyedService.

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_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/common/custom_handlers/protocol_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_job_factory.h"
 
 // This is where handlers for protocols registered with
 // navigator.registerProtocolHandler() are registered. Each Profile owns an
 // instance of this class, which is initialized on browser start through
 // Profile::InitRegisteredProtocolHandlers(), and they should be the only
 // instances of this class.
+class ProtocolHandlerRegistry : public ProfileKeyedService {
 
-class ProtocolHandlerRegistry
-    : public base::RefCountedThreadSafe<
-          ProtocolHandlerRegistry, content::BrowserThread::DeleteOnIOThread> {
  public:
+
+  // Provides notification of when the OS level user agent settings
+  // 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;
@@ skipping 34 matching lines @@
         ProtocolHandlerRegistry* registry);
   };
 
   typedef std::map<std::string, ProtocolHandler> ProtocolHandlerMap;
   typedef std::vector<ProtocolHandler> ProtocolHandlerList;
   typedef std::map<std::string, ProtocolHandlerList> ProtocolHandlerMultiMap;
   typedef std::vector<DefaultClientObserver*> DefaultClientObserverList;
 
   ProtocolHandlerRegistry(Profile* profile, Delegate* delegate);
 
+  // Returns a net::URLRequestJobFactory::Interceptor suitable
+  // for use on the IO thread, but is initialized on the UI thread.
+  // Callers assume responsibility for deleting this object.
+  net::URLRequestJobFactory::Interceptor* CreateIOURLInterceptor();
+
   // 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);
 
   // Called when the user accepts the registration of a given protocol handler.
   void OnAcceptRegisterProtocolHandler(const ProtocolHandler& handler);
 
   // Called when the user denies the registration of a given protocol handler.
@@ skipping 11 matching lines @@
   // Returns a list of protocol handlers that can be replaced by the given
   // handler.
   ProtocolHandlerList GetReplacedHandlers(const ProtocolHandler& handler) const;
 
   // Clears the default for the provided protocol.
   void ClearDefault(const std::string& scheme);
 
   // Returns true if this handler is the default handler for its protocol.
   bool IsDefault(const ProtocolHandler& handler) const;
 
-  // Loads a user's registered protocol handlers.
-  void Load();
+  // Initializes default protocol settings and loads them from prefs.
+  void InitProtocolSettings();
 
   // Returns the offset in the list of handlers for a protocol of the default
   // handler for that protocol.
   int GetHandlerIndex(const std::string& scheme) const;
 
   // Get the list of protocol handlers for the given scheme.
   ProtocolHandlerList GetHandlersFor(const std::string& scheme) const;
 
   // Get the list of ignored protocol handlers.
   ProtocolHandlerList GetIgnoredHandlers();
@@ skipping 17 matching lines @@
 
   // Returns true if an equivalent protocol handler is being ignored.
   bool HasIgnoredEquivalent(const ProtocolHandler& handler) const;
 
   // Causes the given protocol handler to not be ignored anymore.
   void RemoveIgnoredHandler(const ProtocolHandler& handler);
 
   // Returns true if the protocol has a default protocol handler.
   bool IsHandledProtocol(const std::string& scheme) const;
 
-  // Returns true if the protocol has a default protocol handler.
-  // Should be called only from the IO thread.
-  bool IsHandledProtocolIO(const std::string& scheme) const;
-
   // Removes the given protocol handler from the registry.
   void RemoveHandler(const ProtocolHandler& handler);
 
   // Remove the default handler for the given protocol.
   void RemoveDefaultHandler(const std::string& scheme);
 
   // Returns the default handler for this protocol, or an empty handler if none
   // exists.
   const ProtocolHandler& GetHandlerFor(const std::string& scheme) const;
 
-  // Creates a URL request job for the given request if there is a matching
-  // protocol handler, returns NULL otherwise.
-  net::URLRequestJob* MaybeCreateJob(net::URLRequest* request) const;
-
   // 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.
-  void Finalize();
+  virtual void Shutdown() OVERRIDE;
 
   // Registers the preferences that we store registered protocol handlers in.
   static void RegisterPrefs(PrefService* prefService);
 
   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);
 
  private:
   friend class base::DeleteHelper<ProtocolHandlerRegistry>;
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::IO>;
   friend class ProtocolHandlerRegistryTest;
   friend class RegisterProtocolHandlerBrowserTest;
 
-  ~ProtocolHandlerRegistry();
+  // Forward declaration of our internal implementation classes.
+  class Core;
+  class IOURLInterceptor;

[willchan no longer on Chromium, 2012/06/22 23:15:44]

Why does this need to be a private nested class? Can't this be defined
completely in the .cc file? Also, my minor nit is that it should just be named
URLInterceptor. All the Interceptors are on the IO thread in chrome. Naming it
IOURLInterceptor will confuse others into thinking that there are some that work
on a different thread.

[smckay, 2012/06/22 23:44:31]

Since Core is private I have to declare URLInterceptor in the same scope so it
can have access to it. Else I'd have to make URLInterceptor a friend, but I
can't do that because it isn't declared in the .h file. Sorta a catch 22.
Done. Cleaner naming.

+
+  virtual ~ProtocolHandlerRegistry();
 
   // Puts the given handler at the top of the list of handlers for its
   // protocol.
   void PromoteHandler(const ProtocolHandler& handler);
 
-  // Clears the default for the provided protocol.
-  // Should be called only from the IO thread.
-  void ClearDefaultIO(const std::string& scheme);
-
-  // Makes this ProtocolHandler the default handler for its protocol.
-  // Should be called only from the IO thread.
-  void SetDefaultIO(const ProtocolHandler& handler);
-
-  // Indicate that the registry has been enabled in the IO thread's copy of the
-  // data.
-  void EnableIO() { enabled_io_ = true; }
-
-  // Indicate that the registry has been disabled in the IO thread's copy of
-  // the data.
-  void DisableIO() { enabled_io_ = false; }
-
   // Saves a user's registered protocol handlers.
   void Save();
 
   // Returns a pointer to the list of handlers registered for the given scheme,
   // or NULL if there are none.
   const ProtocolHandlerList* GetHandlerList(const std::string& scheme) const;
 
   // Makes this ProtocolHandler the default handler for its protocol.
   void SetDefault(const ProtocolHandler& handler);
 
@@ skipping 34 matching lines @@
   // The Profile that owns this ProtocolHandlerRegistry.
   Profile* profile_;
 
   // The Delegate that registers / deregisters external handlers on our behalf.
   scoped_ptr<Delegate> delegate_;
 
   // If false then registered protocol handlers will not be used to handle
   // requests.
   bool enabled_;
 
-  // Copy of enabled_ that is only accessed on the IO thread.
-  bool enabled_io_;
-
   // Whether or not we are loading.
   bool is_loading_;
 
   // When the table gets loaded this flag will be set and any further calls to
   // AddPredefinedHandler will be rejected.
   bool is_loaded_;
 
+  scoped_refptr<Core> core_;
+
   DefaultClientObserverList default_client_observers_;
 
-  // Copy of default_handlers_ that is only accessed on the IO thread.
-  ProtocolHandlerMap default_handlers_io_;
-
   DISALLOW_COPY_AND_ASSIGN(ProtocolHandlerRegistry);
 };
 #endif  // CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_