Handler settings page.

chrome/browser/custom_handlers/protocol_handler_registry.cc

 // Copyright (c) 2011 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/memory/scoped_ptr.h"
 #include "chrome/browser/custom_handlers/protocol_handler.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/pref_names.h"
 #include "content/browser/child_process_security_policy.h"
+#include "content/common/notification_service.h"
 #include "net/base/network_delegate.h"
 #include "net/url_request/url_request_redirect_job.h"
 
 
 // ProtocolHandlerRegistry -----------------------------------------------------
 
 ProtocolHandlerRegistry::ProtocolHandlerRegistry(Profile* profile,
     Delegate* delegate)
     : profile_(profile),
       delegate_(delegate),
       enabled_(true) {
 }
 
 ProtocolHandlerRegistry::~ProtocolHandlerRegistry() {
 }
 
-ProtocolHandlerRegistry::ProtocolHandlerList&
-ProtocolHandlerRegistry::GetHandlerListFor(const std::string& scheme) {
-  ProtocolHandlerMultiMap::iterator p = protocol_handlers_.find(scheme);
+const ProtocolHandlerRegistry::ProtocolHandlerList*
+ProtocolHandlerRegistry::GetHandlersFor(
+    const std::string& scheme) const {
+  ProtocolHandlerMultiMap::const_iterator p = protocol_handlers_.find(scheme);
   if (p == protocol_handlers_.end()) {
-    protocol_handlers_[scheme] = ProtocolHandlerList();
+    return NULL;
   }
-  return protocol_handlers_[scheme];
+  return &p->second;
 }
 
 void ProtocolHandlerRegistry::RegisterProtocolHandler(
     const ProtocolHandler& handler) {
   DCHECK(CanSchemeBeOverridden(handler.protocol()));
   DCHECK(!handler.IsEmpty());
   if (IsRegistered(handler)) {
     return;
   }
   if (enabled_ && !delegate_->IsExternalHandlerRegistered(handler.protocol())) {
     delegate_->RegisterExternalHandler(handler.protocol());
   }
-  GetHandlerListFor(handler.protocol()).push_back(handler);
+  InsertHandler(handler);
+  Notify(NotificationType::PROTOCOL_HANDLER_REGISTRY_CHANGED);
+}
+
+void ProtocolHandlerRegistry::InsertHandler(const ProtocolHandler& handler) {
+  ProtocolHandlerMultiMap::iterator p =
+    protocol_handlers_.find(handler.protocol());
+
+  if (p != protocol_handlers_.end()) {
+    p->second.push_back(handler);
+    return;
+  }
+
+  ProtocolHandlerList new_list;
+  new_list.push_back(handler);
+  protocol_handlers_[handler.protocol()] = new_list;
 }
 
 void ProtocolHandlerRegistry::IgnoreProtocolHandler(
     const ProtocolHandler& handler) {
   ignored_protocol_handlers_.push_back(handler);
 }
 
 void ProtocolHandlerRegistry::Enable() {
   if (enabled_) {
     return;
   }
   enabled_ = true;
   for (ProtocolHandlerMultiMap::const_iterator p = protocol_handlers_.begin();
        p != protocol_handlers_.end(); ++p) {
     delegate_->RegisterExternalHandler(p->first);
   }
+  Notify(NotificationType::PROTOCOL_HANDLER_REGISTRY_CHANGED);
 }
 
 void ProtocolHandlerRegistry::Disable() {
   if (!enabled_) {
     return;
   }
   enabled_ = false;
   for (ProtocolHandlerMultiMap::const_iterator p = protocol_handlers_.begin();
        p != protocol_handlers_.end(); ++p) {
     delegate_->DeregisterExternalHandler(p->first);
   }
+  Notify(NotificationType::PROTOCOL_HANDLER_REGISTRY_CHANGED);
 }
 
 std::vector<const DictionaryValue*>
 ProtocolHandlerRegistry::GetHandlersFromPref(const char* pref_name) const {
   std::vector<const DictionaryValue*> result;
   PrefService* prefs = profile_->GetPrefs();
   if (!prefs->HasPrefPath(pref_name)) {
     return result;
   }
 
@@ skipping 29 matching lines @@
     }
   }
   std::vector<const DictionaryValue*> ignored_handlers =
     GetHandlersFromPref(prefs::kIgnoredProtocolHandlers);
   for (std::vector<const DictionaryValue*>::const_iterator p =
        ignored_handlers.begin();
        p != ignored_handlers.end(); ++p) {
     IgnoreProtocolHandler(ProtocolHandler::CreateProtocolHandler(*p));
   }
   is_loading_ = false;
+  Notify(NotificationType::PROTOCOL_HANDLER_REGISTRY_LOADED);
 }
 
 void ProtocolHandlerRegistry::RegisterHandlerFromValue(
     const DictionaryValue* value) {
   ProtocolHandler handler = ProtocolHandler::CreateProtocolHandler(value);
   if (!handler.IsEmpty()) {
     RegisterProtocolHandler(handler);
   }
 }
 
@@ skipping 15 matching lines @@
 bool ProtocolHandlerRegistry::CanSchemeBeOverridden(
     const std::string& scheme) const {
   return IsHandledProtocol(scheme) ||
     !delegate_->IsExternalHandlerRegistered(scheme);
 }
 
 void ProtocolHandlerRegistry::GetHandledProtocols(
     std::vector<std::string>* output) const {
   ProtocolHandlerMultiMap::const_iterator p;
   for (p = protocol_handlers_.begin(); p != protocol_handlers_.end(); ++p) {
-    output->push_back(p->first);
+    if (!p->second.empty()) {
+      output->push_back(p->first);
+    }
   }
 }
 
 void ProtocolHandlerRegistry::RemoveIgnoredHandler(
     const ProtocolHandler& handler) {
-  for (ProtocolHandlerList::iterator p = ignored_protocol_handlers_.begin();
-       p != ignored_protocol_handlers_.end(); ++p) {
-    if (handler == *p) {
-      ignored_protocol_handlers_.erase(p);
-      break;
-    }
+  ProtocolHandlerList::iterator p =
+    std::find(ignored_protocol_handlers_.begin(),
+      ignored_protocol_handlers_.end(), handler);
+  if (p != ignored_protocol_handlers_.end()) {
+    ignored_protocol_handlers_.erase(p);
   }
+  Save();
+  Notify(NotificationType::PROTOCOL_HANDLER_REGISTRY_CHANGED);
 }
 
-bool ProtocolHandlerRegistry::IsRegistered(const ProtocolHandler& handler) {
-  ProtocolHandlerList& handlers(GetHandlerListFor(handler.protocol()));
-  return std::find(handlers.begin(), handlers.end(), handler) != handlers.end();
+bool ProtocolHandlerRegistry::IsRegistered(
+        const ProtocolHandler& handler) const {
+  const ProtocolHandlerList* handlers = GetHandlersFor(handler.protocol());
+  if (!handlers) {
+    return false;
+  }
+  return std::find(handlers->begin(), handlers->end(), handler) !=
+      handlers->end();
 }
 
 bool ProtocolHandlerRegistry::IsIgnored(const ProtocolHandler& handler) const {
   ProtocolHandlerList::const_iterator i;
   for (i = ignored_protocol_handlers_.begin();
       i != ignored_protocol_handlers_.end(); ++i) {
     if (*i == handler) {
       return true;
     }
   }
   return false;
 }
 
 bool ProtocolHandlerRegistry::IsHandledProtocol(
     const std::string& scheme) const {
-  return protocol_handlers_.find(scheme) != protocol_handlers_.end();
+  return !GetHandlerFor(scheme).IsEmpty();
 }
 
 void ProtocolHandlerRegistry::RemoveHandler(const ProtocolHandler& handler) {
-  ProtocolHandlerList& handlers(GetHandlerListFor(handler.protocol()));
+  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 it = default_handlers_.find(handler.protocol());
-  if (it != default_handlers_.end() && it->second == handler) {
-    default_handlers_.erase(it);
+  ProtocolHandlerMap::iterator q = default_handlers_.find(handler.protocol());
+  if (q != default_handlers_.end() && q->second == handler) {
+    default_handlers_.erase(q);
   }
+
+  if (!IsHandledProtocol(handler.protocol())) {
+    delegate_->DeregisterExternalHandler(handler.protocol());
+  }
+  Save();
+  Notify(NotificationType::PROTOCOL_HANDLER_REGISTRY_CHANGED);
 }
 
 net::URLRequestJob* ProtocolHandlerRegistry::MaybeCreateJob(
     net::URLRequest* request) const {
   ProtocolHandler handler = GetHandlerFor(request->url().scheme());
 
   if (handler.IsEmpty()) {
     return NULL;
   }
 
@@ skipping 55 matching lines @@
   pref_service->RegisterListPref(prefs::kIgnoredProtocolHandlers,
                                  PrefService::UNSYNCABLE_PREF);
   pref_service->RegisterBooleanPref(prefs::kCustomHandlersEnabled, true,
                                     PrefService::UNSYNCABLE_PREF);
 }
 
 void ProtocolHandlerRegistry::SetDefault(const ProtocolHandler& handler) {
   default_handlers_.erase(handler.protocol());
   default_handlers_.insert(std::make_pair(handler.protocol(), handler));
   Save();
+  Notify(NotificationType::PROTOCOL_HANDLER_REGISTRY_CHANGED);
 }
 
 void ProtocolHandlerRegistry::ClearDefault(const std::string& scheme) {
   default_handlers_.erase(scheme);
   Save();
+  Notify(NotificationType::PROTOCOL_HANDLER_REGISTRY_CHANGED);
 }
 
 bool ProtocolHandlerRegistry::IsDefault(const ProtocolHandler& handler) const {
   return GetHandlerFor(handler.protocol()) == handler;
 }
 
 const ProtocolHandler& ProtocolHandlerRegistry::GetHandlerFor(
     const std::string& scheme) const {
   ProtocolHandlerMap::const_iterator p = default_handlers_.find(scheme);
   if (p != default_handlers_.end()) {
     return p->second;
   }
-  ProtocolHandlerMultiMap::const_iterator q =
-    protocol_handlers_.find(scheme);
-  if (q != protocol_handlers_.end() && q->second.size() == 1) {
-    return q->second[0];
+  ProtocolHandlerMultiMap::const_iterator q = protocol_handlers_.find(scheme);
+  if (q == protocol_handlers_.end() || q->second.empty()) {
+    return ProtocolHandler::EmptyProtocolHandler();
   }
-  return ProtocolHandler::EmptyProtocolHandler();
+  return q->second.back();
+}
+
+int ProtocolHandlerRegistry::GetHandlerIndex(const std::string& scheme) const {
+  const ProtocolHandler& handler = GetHandlerFor(scheme);
+  const ProtocolHandlerList* handlers = GetHandlersFor(scheme);
+  if (!handlers) {
+    return -1;
+  }
+
+  ProtocolHandlerList::const_iterator p;
+  int i;
+  for (i = 0, p = handlers->begin(); p != handlers->end(); ++p, ++i) {
+    if (*p == handler) {
+      return i;
+    }
+  }
+  return -1;
 }
 
 bool ProtocolHandlerRegistry::HasDefault(
     const std::string& scheme) const {
   return !GetHandlerFor(scheme).IsEmpty();
 }
 
-bool ProtocolHandlerRegistry::HasHandler(const std::string& scheme) {
-  return !GetHandlerListFor(scheme).empty();
-}
-
 // Delegate --------------------------------------------------------------------
 
 ProtocolHandlerRegistry::Delegate::~Delegate() {
 }
 
 void ProtocolHandlerRegistry::Delegate::RegisterExternalHandler(
     const std::string& protocol) {
   ChildProcessSecurityPolicy* policy =
     ChildProcessSecurityPolicy::GetInstance();
   if (!policy->IsWebSafeScheme(protocol)) {
     policy->RegisterWebSafeScheme(protocol);
   }
 }
 
 void ProtocolHandlerRegistry::Delegate::DeregisterExternalHandler(
     const std::string& protocol) {
 }
 
 bool ProtocolHandlerRegistry::Delegate::IsExternalHandlerRegistered(
     const std::string& protocol) {
   return ProfileIOData::IsHandledProtocol(protocol);
 }
+
+void ProtocolHandlerRegistry::Notify(NotificationType type) {
+  NotificationService::current()->Notify(type,
+      Source<Profile>(profile_),
+      NotificationService::NoDetails());
+}