Convert ProtocolHandlerRegistry to be a ProfileKeyedService.

chrome/browser/custom_handlers/protocol_handler_registry.cc

 // 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.
 
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/custom_handlers/register_protocol_handler_infobar_delegate.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/custom_handlers/protocol_handler.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/notification_service.h"
+#include "grit/generated_resources.h"
 #include "net/base/network_delegate.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_redirect_job.h"
+#include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 
 namespace {
 
+const ProtocolHandler& LookupHandler(
+    const ProtocolHandlerRegistry::ProtocolHandlerMap& handler_map,
+    const std::string& scheme) {
+  ProtocolHandlerRegistry::ProtocolHandlerMap::const_iterator p =
+      handler_map.find(scheme);
+
+  if (p != handler_map.end())
+    return p->second;
+
+  return ProtocolHandler::EmptyProtocolHandler();
+}
+
 // If true default protocol handlers will be removed if the OS level
 // registration for a protocol is no longer Chrome.
 bool ShouldRemoveHandlersNotInOS() {
 #if defined(OS_LINUX)
   // We don't do this on Linux as the OS registration there is not reliable,
   // and Chrome OS doesn't have any notion of OS registration.
   // TODO(benwells): When Linux support is more reliable remove this
   // difference (http://crbug.com/88255).
   return false;
 #else
   return ShellIntegration::CanSetAsDefaultProtocolClient() !=
       ShellIntegration::SET_DEFAULT_NOT_ALLOWED;
 #endif
 }
 
-} // namespace
+}  // namespace
 
-static const ProtocolHandler& LookupHandler(
-    const ProtocolHandlerRegistry::ProtocolHandlerMap& handler_map,
-    const std::string& scheme) {
-  ProtocolHandlerRegistry::ProtocolHandlerMap::const_iterator p =
-      handler_map.find(scheme);
-  if (p != handler_map.end()) {
-    return p->second;
+// Core ------------------------------------------------------------------------
+
+// Core is an IO thread specific object. Access to the class should all
+// be done via the IO thread. The registry living on the UI thread makes
+// a best effort to update the IO object after local updates are completed.
+class ProtocolHandlerRegistry::Core
+    : public base::RefCountedThreadSafe<ProtocolHandlerRegistry::Core> {
+ public:
+
+  // Creates a new instance. If |enabled| is true the registry is considered
+  // enabled on the IO thread.
+  explicit Core(bool enabled);
+
+  // Returns true if the protocol has a default protocol handler.
+  // Should be called only from the IO thread.
+  bool IsHandledProtocol(const std::string& scheme) const;
+
+  // Clears the default for the provided protocol.
+  // Should be called only from the IO thread.
+  void ClearDefault(const std::string& scheme);
+
+  // Makes this ProtocolHandler the default handler for its protocol.
+  // Should be called only from the IO thread.
+  void SetDefault(const ProtocolHandler& handler);
+
+  // 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;
+
+  // Indicate that the registry has been enabled in the IO thread's
+  // copy of the data.
+  void Enable() { enabled_ = true; }
+
+  // Indicate that the registry has been disabled in the IO thread's copy of
+  // the data.
+  void Disable() { enabled_ = false; }
+
+ private:
+  friend class base::RefCountedThreadSafe<Core>;
+  virtual ~Core();
+
+  // Copy of protocol handlers use only on the IO thread.
+  ProtocolHandlerRegistry::ProtocolHandlerMap default_handlers_;
+
+  // Is the registry enabled on the IO thread.
+  bool enabled_;
+
+  DISALLOW_COPY_AND_ASSIGN(Core);
+};
+
+ProtocolHandlerRegistry::Core::Core(bool) : enabled_(true) {}
+ProtocolHandlerRegistry::Core::~Core() {}
+
+bool ProtocolHandlerRegistry::Core::IsHandledProtocol(
+    const std::string& scheme) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  return enabled_ && !LookupHandler(default_handlers_, scheme).IsEmpty();
+}
+
+void ProtocolHandlerRegistry::Core::ClearDefault(const std::string& scheme) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  default_handlers_.erase(scheme);
+}
+
+void ProtocolHandlerRegistry::Core::SetDefault(const ProtocolHandler& handler) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  ClearDefault(handler.protocol());
+  default_handlers_.insert(std::make_pair(handler.protocol(), handler));
+}
+
+// Create a new job for the supplied |URLRequest| if a default handler
+// is registered and the associated handler is able to interpret
+// the url from |request|.
+net::URLRequestJob* ProtocolHandlerRegistry::Core::MaybeCreateJob(
+    net::URLRequest* request) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  ProtocolHandler handler = LookupHandler(default_handlers_,
+                                          request->url().scheme());
+  if (handler.IsEmpty())
+    return NULL;
+
+  GURL translated_url(handler.TranslateUrl(request->url()));
+  if (!translated_url.is_valid())
+    return NULL;
+
+  return new net::URLRequestRedirectJob(request, translated_url);
+}
+
+// URLInterceptor ------------------------------------------------------------
+
+// Instances of this class are produced for ownership by the IO
+// thread where it handler URL requests. We should never hold
+// any pointers on this class, only produce them in response to
+// requests via |ProtocolHandlerRegistry::CreateURLInterceptor|.
+class ProtocolHandlerRegistry::URLInterceptor
+    : public net::URLRequestJobFactory::Interceptor {
+ public:
+  explicit URLInterceptor(Core* core);
+  virtual ~URLInterceptor();
+
+  virtual net::URLRequestJob* MaybeIntercept(
+      net::URLRequest* request) const OVERRIDE;
+
+  virtual bool WillHandleProtocol(const std::string& protocol) const OVERRIDE;
+
+  virtual net::URLRequestJob* MaybeInterceptRedirect(
+      const GURL& url, net::URLRequest* request) const OVERRIDE {
+    return NULL;
   }
-  return ProtocolHandler::EmptyProtocolHandler();
+
+  virtual net::URLRequestJob* MaybeInterceptResponse(
+      net::URLRequest* request) const OVERRIDE {
+    return NULL;
+  }
+
+ private:
+  scoped_refptr<Core> core_;
+  DISALLOW_COPY_AND_ASSIGN(URLInterceptor);
+};
+
+ProtocolHandlerRegistry::URLInterceptor::URLInterceptor(Core* core)
+    : core_(core) {
+  DCHECK(core_);
+}
+
+ProtocolHandlerRegistry::URLInterceptor::~URLInterceptor() {
+}
+
+net::URLRequestJob* ProtocolHandlerRegistry::URLInterceptor::MaybeIntercept(
+    net::URLRequest* request) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  return core_->MaybeCreateJob(request);
+}
+
+bool ProtocolHandlerRegistry::URLInterceptor::WillHandleProtocol(
+    const std::string& protocol) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  return core_->IsHandledProtocol(protocol);
 }
 
 // DefaultClientObserver ------------------------------------------------------
 
 ProtocolHandlerRegistry::DefaultClientObserver::DefaultClientObserver(
     ProtocolHandlerRegistry* registry)
     : worker_(NULL),
       registry_(registry) {
   DCHECK(registry_);
 }
 
 ProtocolHandlerRegistry::DefaultClientObserver::~DefaultClientObserver() {
   if (worker_)
     worker_->ObserverDestroyed();
 
   DefaultClientObserverList::iterator iter = std::find(
       registry_->default_client_observers_.begin(),
       registry_->default_client_observers_.end(), this);
   registry_->default_client_observers_.erase(iter);
 }
 
-void
-ProtocolHandlerRegistry::DefaultClientObserver::SetDefaultWebClientUIState(
+void ProtocolHandlerRegistry::DefaultClientObserver::SetDefaultWebClientUIState(
     ShellIntegration::DefaultWebClientUIState state) {
   if (worker_) {
     if (ShouldRemoveHandlersNotInOS() &&
         (state == ShellIntegration::STATE_NOT_DEFAULT)) {
       registry_->ClearDefault(worker_->protocol());
     }
   } else {
     NOTREACHED();
   }
 }
@@ skipping 53 matching lines @@
   worker->StartSetAsDefault();
 }
 
 // ProtocolHandlerRegistry -----------------------------------------------------
 
 ProtocolHandlerRegistry::ProtocolHandlerRegistry(Profile* profile,
     Delegate* delegate)
     : profile_(profile),
       delegate_(delegate),
       enabled_(true),
-      enabled_io_(enabled_),
       is_loading_(false),
-      is_loaded_(false) {
+      is_loaded_(false),
+      core_(new Core(enabled_)){
 }
 
 bool ProtocolHandlerRegistry::SilentlyHandleRegisterHandlerRequest(
     const ProtocolHandler& handler) {
   if (handler.IsEmpty() || !CanSchemeBeOverridden(handler.protocol()))
     return true;
 
   if (!enabled() || IsRegistered(handler) || HasIgnoredEquivalent(handler))
     return true;
 
@@ skipping 59 matching lines @@
        p != handlers->end(); p++) {
     if (handler.IsSameOrigin(*p)) {
       replaced_handlers.push_back(*p);
     }
   }
   return replaced_handlers;
 }
 
 void ProtocolHandlerRegistry::ClearDefault(const std::string& scheme) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   default_handlers_.erase(scheme);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&ProtocolHandlerRegistry::ClearDefaultIO, this, scheme));
+      base::Bind(&Core::ClearDefault, core_, scheme));
   Save();
   NotifyChanged();
 }
 
 bool ProtocolHandlerRegistry::IsDefault(
     const ProtocolHandler& handler) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return GetHandlerFor(handler.protocol()) == handler;
 }
 
-void ProtocolHandlerRegistry::Load() {
+void ProtocolHandlerRegistry::InstallDefaultsForChromeOS() {
+#if defined(OS_CHROMEOS)
+  // Only chromeos has default protocol handlers at this point.
+  AddPredefinedHandler(
+      ProtocolHandler::CreateProtocolHandler(
+          "mailto",
+          GURL(l10n_util::GetStringUTF8(IDS_GOOGLE_MAILTO_HANDLER_URL)),
+          l10n_util::GetStringUTF16(IDS_GOOGLE_MAILTO_HANDLER_NAME)));
+  AddPredefinedHandler(
+      ProtocolHandler::CreateProtocolHandler(
+          "webcal",
+          GURL(l10n_util::GetStringUTF8(IDS_GOOGLE_WEBCAL_HANDLER_URL)),
+          l10n_util::GetStringUTF16(IDS_GOOGLE_WEBCAL_HANDLER_NAME)));
+#else
+  NOTREACHED();  // this method should only ever be called in chromeos.
+#endif
+}
+
+void ProtocolHandlerRegistry::InitProtocolSettings() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   // Any further default additions to the table will get rejected from now on.
   is_loaded_ = true;
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   is_loading_ = true;
+
   PrefService* prefs = profile_->GetPrefs();
   if (prefs->HasPrefPath(prefs::kCustomHandlersEnabled)) {
-    enabled_ = prefs->GetBoolean(prefs::kCustomHandlersEnabled);
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(enabled_ ? &ProtocolHandlerRegistry::EnableIO :
-                   &ProtocolHandlerRegistry::DisableIO, this));
+    if (prefs->GetBoolean(prefs::kCustomHandlersEnabled)) {
+      Enable();
+    } else {
+      Disable();
+    }
   }
   std::vector<const DictionaryValue*> registered_handlers =
       GetHandlersFromPref(prefs::kRegisteredProtocolHandlers);
   for (std::vector<const DictionaryValue*>::const_iterator p =
        registered_handlers.begin();
        p != registered_handlers.end(); ++p) {
     ProtocolHandler handler = ProtocolHandler::CreateProtocolHandler(*p);
     RegisterProtocolHandler(handler);
     bool is_default = false;
     if ((*p)->GetBoolean("default", &is_default) && is_default) {
@@ skipping 147 matching lines @@
   if (should_notify)
     NotifyChanged();
 }
 
 bool ProtocolHandlerRegistry::IsHandledProtocol(
     const std::string& scheme) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return enabled_ && !GetHandlerFor(scheme).IsEmpty();
 }
 
-bool ProtocolHandlerRegistry::IsHandledProtocolIO(
-    const std::string& scheme) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  return enabled_io_ && !LookupHandler(default_handlers_io_, scheme).IsEmpty();
-}
-
 void ProtocolHandlerRegistry::RemoveHandler(
     const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProtocolHandlerList& handlers = protocol_handlers_[handler.protocol()];
   ProtocolHandlerList::iterator p =
       std::find(handlers.begin(), handlers.end(), handler);
   if (p != handlers.end()) {
     handlers.erase(p);
   }
   ProtocolHandlerMap::iterator q = default_handlers_.find(handler.protocol());
   if (q != default_handlers_.end() && q->second == handler) {
     // Make the new top handler in the list the default.
     if (!handlers.empty()) {
       // NOTE We pass a copy because SetDefault() modifies handlers.
       SetDefault(ProtocolHandler(handlers[0]));
     } else {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
-          base::Bind(&ProtocolHandlerRegistry::ClearDefaultIO, this,
-                     q->second.protocol()));
+          base::Bind(&Core::ClearDefault, core_, q->second.protocol()));
+
       default_handlers_.erase(q);
     }
   }
 
   if (!IsHandledProtocol(handler.protocol())) {
     delegate_->DeregisterExternalHandler(handler.protocol());
   }
   Save();
   NotifyChanged();
 }
 
 void ProtocolHandlerRegistry::RemoveDefaultHandler(const std::string& scheme) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProtocolHandler current_default = GetHandlerFor(scheme);
   if (!current_default.IsEmpty())
     RemoveHandler(current_default);
 }
 
 const ProtocolHandler& ProtocolHandlerRegistry::GetHandlerFor(
     const std::string& scheme) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return LookupHandler(default_handlers_, scheme);
 }
 
-net::URLRequestJob* ProtocolHandlerRegistry::MaybeCreateJob(
-    net::URLRequest* request) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ProtocolHandler handler = LookupHandler(default_handlers_io_,
-                                          request->url().scheme());
-  if (handler.IsEmpty()) {
-    return NULL;
-  }
-  GURL translated_url(handler.TranslateUrl(request->url()));
-  if (!translated_url.is_valid()) {
-    return NULL;
-  }
-  return new net::URLRequestRedirectJob(request, translated_url);
-}
-
 void ProtocolHandlerRegistry::Enable() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (enabled_) {
     return;
   }
   enabled_ = true;
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&ProtocolHandlerRegistry::EnableIO, this));
+      base::Bind(&Core::Enable, core_));
+
   ProtocolHandlerMap::const_iterator p;
   for (p = default_handlers_.begin(); p != default_handlers_.end(); ++p) {
     delegate_->RegisterExternalHandler(p->first);
   }
   Save();
   NotifyChanged();
 }
 
 void ProtocolHandlerRegistry::Disable() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!enabled_) {
     return;
   }
   enabled_ = false;
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&ProtocolHandlerRegistry::DisableIO, this));
+      base::Bind(&Core::Disable, core_));
+
   ProtocolHandlerMap::const_iterator p;
   for (p = default_handlers_.begin(); p != default_handlers_.end(); ++p) {
     delegate_->DeregisterExternalHandler(p->first);
   }
   Save();
   NotifyChanged();
 }
 
-void ProtocolHandlerRegistry::Finalize() {
+void ProtocolHandlerRegistry::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   delegate_.reset(NULL);
   // We free these now in case there are any outstanding workers running. If
   // we didn't free them they could respond to workers and try to update the
   // protocol handler registry after it was deleted.
   // Observers remove themselves from this list when they are deleted; so
   // we delete the last item until none are left in the list.
   while (!default_client_observers_.empty()) {
     delete default_client_observers_.back();
   }
 }
 
 // static
 void ProtocolHandlerRegistry::RegisterPrefs(PrefService* pref_service) {
   pref_service->RegisterListPref(prefs::kRegisteredProtocolHandlers,
                                  PrefService::UNSYNCABLE_PREF);
   pref_service->RegisterListPref(prefs::kIgnoredProtocolHandlers,
                                  PrefService::UNSYNCABLE_PREF);
   pref_service->RegisterBooleanPref(prefs::kCustomHandlersEnabled, true,
                                     PrefService::UNSYNCABLE_PREF);
 }
 
 ProtocolHandlerRegistry::~ProtocolHandlerRegistry() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(default_client_observers_.empty());
 }
 
 void ProtocolHandlerRegistry::PromoteHandler(const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(IsRegistered(handler));
   ProtocolHandlerMultiMap::iterator p =
       protocol_handlers_.find(handler.protocol());
   ProtocolHandlerList& list = p->second;
   list.erase(std::find(list.begin(), list.end(), handler));
   list.insert(list.begin(), handler);
 }
 
-void ProtocolHandlerRegistry::ClearDefaultIO(const std::string& scheme) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  default_handlers_io_.erase(scheme);
-}
-
-void ProtocolHandlerRegistry::SetDefaultIO(const ProtocolHandler& handler) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ClearDefaultIO(handler.protocol());
-  default_handlers_io_.insert(std::make_pair(handler.protocol(), handler));
-}
-
 void ProtocolHandlerRegistry::Save() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (is_loading_) {
     return;
   }
   scoped_ptr<Value> registered_protocol_handlers(EncodeRegisteredHandlers());
   scoped_ptr<Value> ignored_protocol_handlers(EncodeIgnoredHandlers());
   scoped_ptr<Value> enabled(Value::CreateBooleanValue(enabled_));
   profile_->GetPrefs()->Set(prefs::kRegisteredProtocolHandlers,
       *registered_protocol_handlers);
@@ skipping 20 matching lines @@
   // If we're not loading, and we are setting a default for a new protocol,
   // register with the OS.
   if (!is_loading_ && p == default_handlers_.end())
       delegate_->RegisterWithOSAsDefaultClient(handler.protocol(), this);
   default_handlers_.erase(handler.protocol());
   default_handlers_.insert(std::make_pair(handler.protocol(), handler));
   PromoteHandler(handler);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&ProtocolHandlerRegistry::SetDefaultIO, this, handler));
+      base::Bind(&Core::SetDefault, core_, handler));
 }
 
 void ProtocolHandlerRegistry::InsertHandler(const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProtocolHandlerMultiMap::iterator p =
       protocol_handlers_.find(handler.protocol());
 
   if (p != protocol_handlers_.end()) {
     p->second.push_back(handler);
     return;
@@ skipping 76 matching lines @@
 }
 
 void ProtocolHandlerRegistry::IgnoreProtocolHandler(
     const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ignored_protocol_handlers_.push_back(handler);
 }
 
 void ProtocolHandlerRegistry::AddPredefinedHandler(
     const ProtocolHandler& handler) {
-  // If called after the load command was issued this function will fail.
-  DCHECK(!is_loaded_);
+  DCHECK(!is_loaded_);  // Must be called prior InitProtocolSettings.
   RegisterProtocolHandler(handler);
   SetDefault(handler);
 }
 
-
+net::URLRequestJobFactory::Interceptor*
+    ProtocolHandlerRegistry::CreateURLInterceptor() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // this is always created on the UI thread (in profile_io's
+  // InitializeOnUIThread. Any method calls must be done
+  // on the IO thread (this is checked).
+  return new URLInterceptor(core_);
+}