Home | History | Annotate | Download | only in custom_handlers 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
      6 
      7 #include <utility>
      8 
      9 #include "base/bind.h"
     10 #include "base/command_line.h"
     11 #include "base/logging.h"
     12 #include "base/prefs/pref_service.h"
     13 #include "chrome/browser/chrome_notification_types.h"
     14 #include "chrome/browser/custom_handlers/register_protocol_handler_infobar_delegate.h"
     15 #include "chrome/browser/profiles/profile_io_data.h"
     16 #include "chrome/common/custom_handlers/protocol_handler.h"
     17 #include "chrome/common/pref_names.h"
     18 #include "chrome/grit/generated_resources.h"
     19 #include "components/pref_registry/pref_registry_syncable.h"
     20 #include "components/user_prefs/user_prefs.h"
     21 #include "content/public/browser/child_process_security_policy.h"
     22 #include "net/base/network_delegate.h"
     23 #include "net/url_request/url_request_redirect_job.h"
     24 #include "ui/base/l10n/l10n_util.h"
     25 
     26 using content::BrowserThread;
     27 using content::ChildProcessSecurityPolicy;
     28 
     29 namespace {
     30 
     31 const ProtocolHandler& LookupHandler(
     32     const ProtocolHandlerRegistry::ProtocolHandlerMap& handler_map,
     33     const std::string& scheme) {
     34   ProtocolHandlerRegistry::ProtocolHandlerMap::const_iterator p =
     35       handler_map.find(scheme);
     36 
     37   if (p != handler_map.end())
     38     return p->second;
     39 
     40   return ProtocolHandler::EmptyProtocolHandler();
     41 }
     42 
     43 // If true default protocol handlers will be removed if the OS level
     44 // registration for a protocol is no longer Chrome.
     45 bool ShouldRemoveHandlersNotInOS() {
     46 #if defined(OS_LINUX)
     47   // We don't do this on Linux as the OS registration there is not reliable,
     48   // and Chrome OS doesn't have any notion of OS registration.
     49   // TODO(benwells): When Linux support is more reliable remove this
     50   // difference (http://crbug.com/88255).
     51   return false;
     52 #else
     53   return ShellIntegration::CanSetAsDefaultProtocolClient() !=
     54       ShellIntegration::SET_DEFAULT_NOT_ALLOWED;
     55 #endif
     56 }
     57 
     58 }  // namespace
     59 
     60 // IOThreadDelegate ------------------------------------------------------------
     61 
     62 // IOThreadDelegate is an IO thread specific object. Access to the class should
     63 // all be done via the IO thread. The registry living on the UI thread makes
     64 // a best effort to update the IO object after local updates are completed.
     65 class ProtocolHandlerRegistry::IOThreadDelegate
     66     : public base::RefCountedThreadSafe<
     67           ProtocolHandlerRegistry::IOThreadDelegate> {
     68  public:
     69 
     70   // Creates a new instance. If |enabled| is true the registry is considered
     71   // enabled on the IO thread.
     72   explicit IOThreadDelegate(bool enabled);
     73 
     74   // Returns true if the protocol has a default protocol handler.
     75   // Should be called only from the IO thread.
     76   bool IsHandledProtocol(const std::string& scheme) const;
     77 
     78   // Clears the default for the provided protocol.
     79   // Should be called only from the IO thread.
     80   void ClearDefault(const std::string& scheme);
     81 
     82   // Makes this ProtocolHandler the default handler for its protocol.
     83   // Should be called only from the IO thread.
     84   void SetDefault(const ProtocolHandler& handler);
     85 
     86   // Creates a URL request job for the given request if there is a matching
     87   // protocol handler, returns NULL otherwise.
     88   net::URLRequestJob* MaybeCreateJob(
     89       net::URLRequest* request, net::NetworkDelegate* network_delegate) const;
     90 
     91   // Indicate that the registry has been enabled in the IO thread's
     92   // copy of the data.
     93   void Enable() { enabled_ = true; }
     94 
     95   // Indicate that the registry has been disabled in the IO thread's copy of
     96   // the data.
     97   void Disable() { enabled_ = false; }
     98 
     99  private:
    100   friend class base::RefCountedThreadSafe<IOThreadDelegate>;
    101   virtual ~IOThreadDelegate();
    102 
    103   // Copy of protocol handlers use only on the IO thread.
    104   ProtocolHandlerRegistry::ProtocolHandlerMap default_handlers_;
    105 
    106   // Is the registry enabled on the IO thread.
    107   bool enabled_;
    108 
    109   DISALLOW_COPY_AND_ASSIGN(IOThreadDelegate);
    110 };
    111 
    112 ProtocolHandlerRegistry::IOThreadDelegate::IOThreadDelegate(bool)
    113     : enabled_(true) {}
    114 ProtocolHandlerRegistry::IOThreadDelegate::~IOThreadDelegate() {}
    115 
    116 bool ProtocolHandlerRegistry::IOThreadDelegate::IsHandledProtocol(
    117     const std::string& scheme) const {
    118   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    119   return enabled_ && !LookupHandler(default_handlers_, scheme).IsEmpty();
    120 }
    121 
    122 void ProtocolHandlerRegistry::IOThreadDelegate::ClearDefault(
    123     const std::string& scheme) {
    124   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    125   default_handlers_.erase(scheme);
    126 }
    127 
    128 void ProtocolHandlerRegistry::IOThreadDelegate::SetDefault(
    129     const ProtocolHandler& handler) {
    130   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    131   ClearDefault(handler.protocol());
    132   default_handlers_.insert(std::make_pair(handler.protocol(), handler));
    133 }
    134 
    135 // Create a new job for the supplied |URLRequest| if a default handler
    136 // is registered and the associated handler is able to interpret
    137 // the url from |request|.
    138 net::URLRequestJob* ProtocolHandlerRegistry::IOThreadDelegate::MaybeCreateJob(
    139     net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
    140   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    141 
    142   ProtocolHandler handler = LookupHandler(default_handlers_,
    143                                           request->url().scheme());
    144   if (handler.IsEmpty())
    145     return NULL;
    146 
    147   GURL translated_url(handler.TranslateUrl(request->url()));
    148   if (!translated_url.is_valid())
    149     return NULL;
    150 
    151   return new net::URLRequestRedirectJob(
    152       request, network_delegate, translated_url,
    153       net::URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT,
    154       "Protocol Handler Registry");
    155 }
    156 
    157 // JobInterceptorFactory -------------------------------------------------------
    158 
    159 // Instances of JobInterceptorFactory are produced for ownership by the IO
    160 // thread where it handler URL requests. We should never hold
    161 // any pointers on this class, only produce them in response to
    162 // requests via |ProtocolHandlerRegistry::CreateJobInterceptorFactory|.
    163 ProtocolHandlerRegistry::JobInterceptorFactory::JobInterceptorFactory(
    164     IOThreadDelegate* io_thread_delegate)
    165     : io_thread_delegate_(io_thread_delegate) {
    166   DCHECK(io_thread_delegate_.get());
    167   DetachFromThread();
    168 }
    169 
    170 ProtocolHandlerRegistry::JobInterceptorFactory::~JobInterceptorFactory() {
    171 }
    172 
    173 void ProtocolHandlerRegistry::JobInterceptorFactory::Chain(
    174     scoped_ptr<net::URLRequestJobFactory> job_factory) {
    175   job_factory_ = job_factory.Pass();
    176 }
    177 
    178 net::URLRequestJob*
    179 ProtocolHandlerRegistry::JobInterceptorFactory::
    180 MaybeCreateJobWithProtocolHandler(
    181     const std::string& scheme,
    182     net::URLRequest* request,
    183     net::NetworkDelegate* network_delegate) const {
    184   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    185   net::URLRequestJob* job = io_thread_delegate_->MaybeCreateJob(
    186       request, network_delegate);
    187   if (job)
    188     return job;
    189   return job_factory_->MaybeCreateJobWithProtocolHandler(
    190       scheme, request, network_delegate);
    191 }
    192 
    193 bool ProtocolHandlerRegistry::JobInterceptorFactory::IsHandledProtocol(
    194     const std::string& scheme) const {
    195   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    196   return io_thread_delegate_->IsHandledProtocol(scheme) ||
    197       job_factory_->IsHandledProtocol(scheme);
    198 }
    199 
    200 bool ProtocolHandlerRegistry::JobInterceptorFactory::IsHandledURL(
    201     const GURL& url) const {
    202   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    203   return (url.is_valid() &&
    204       io_thread_delegate_->IsHandledProtocol(url.scheme())) ||
    205       job_factory_->IsHandledURL(url);
    206 }
    207 
    208 bool ProtocolHandlerRegistry::JobInterceptorFactory::IsSafeRedirectTarget(
    209     const GURL& location) const {
    210   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    211   return job_factory_->IsSafeRedirectTarget(location);
    212 }
    213 
    214 // DefaultClientObserver ------------------------------------------------------
    215 
    216 ProtocolHandlerRegistry::DefaultClientObserver::DefaultClientObserver(
    217     ProtocolHandlerRegistry* registry)
    218     : worker_(NULL),
    219       registry_(registry) {
    220   DCHECK(registry_);
    221 }
    222 
    223 ProtocolHandlerRegistry::DefaultClientObserver::~DefaultClientObserver() {
    224   if (worker_)
    225     worker_->ObserverDestroyed();
    226 
    227   DefaultClientObserverList::iterator iter = std::find(
    228       registry_->default_client_observers_.begin(),
    229       registry_->default_client_observers_.end(), this);
    230   registry_->default_client_observers_.erase(iter);
    231 }
    232 
    233 void ProtocolHandlerRegistry::DefaultClientObserver::SetDefaultWebClientUIState(
    234     ShellIntegration::DefaultWebClientUIState state) {
    235   if (worker_) {
    236     if (ShouldRemoveHandlersNotInOS() &&
    237         (state == ShellIntegration::STATE_NOT_DEFAULT)) {
    238       registry_->ClearDefault(worker_->protocol());
    239     }
    240   } else {
    241     NOTREACHED();
    242   }
    243 }
    244 
    245 bool ProtocolHandlerRegistry::DefaultClientObserver::
    246     IsInteractiveSetDefaultPermitted() {
    247   return true;
    248 }
    249 
    250 void ProtocolHandlerRegistry::DefaultClientObserver::SetWorker(
    251     ShellIntegration::DefaultProtocolClientWorker* worker) {
    252   worker_ = worker;
    253 }
    254 
    255 bool ProtocolHandlerRegistry::DefaultClientObserver::IsOwnedByWorker() {
    256   return true;
    257 }
    258 
    259 // Delegate --------------------------------------------------------------------
    260 
    261 ProtocolHandlerRegistry::Delegate::~Delegate() {}
    262 
    263 void ProtocolHandlerRegistry::Delegate::RegisterExternalHandler(
    264     const std::string& protocol) {
    265   ChildProcessSecurityPolicy* policy =
    266     ChildProcessSecurityPolicy::GetInstance();
    267   if (!policy->IsWebSafeScheme(protocol)) {
    268     policy->RegisterWebSafeScheme(protocol);
    269   }
    270 }
    271 
    272 void ProtocolHandlerRegistry::Delegate::DeregisterExternalHandler(
    273     const std::string& protocol) {
    274 }
    275 
    276 bool ProtocolHandlerRegistry::Delegate::IsExternalHandlerRegistered(
    277     const std::string& protocol) {
    278   // NOTE(koz): This function is safe to call from any thread, despite living
    279   // in ProfileIOData.
    280   return ProfileIOData::IsHandledProtocol(protocol);
    281 }
    282 
    283 ShellIntegration::DefaultProtocolClientWorker*
    284 ProtocolHandlerRegistry::Delegate::CreateShellWorker(
    285     ShellIntegration::DefaultWebClientObserver* observer,
    286     const std::string& protocol) {
    287   return new ShellIntegration::DefaultProtocolClientWorker(observer, protocol);
    288 }
    289 
    290 ProtocolHandlerRegistry::DefaultClientObserver*
    291 ProtocolHandlerRegistry::Delegate::CreateShellObserver(
    292     ProtocolHandlerRegistry* registry) {
    293   return new DefaultClientObserver(registry);
    294 }
    295 
    296 void ProtocolHandlerRegistry::Delegate::RegisterWithOSAsDefaultClient(
    297     const std::string& protocol, ProtocolHandlerRegistry* registry) {
    298   DefaultClientObserver* observer = CreateShellObserver(registry);
    299   // The worker pointer is reference counted. While it is running the
    300   // message loops of the FILE and UI thread will hold references to it
    301   // and it will be automatically freed once all its tasks have finished.
    302   scoped_refptr<ShellIntegration::DefaultProtocolClientWorker> worker;
    303   worker = CreateShellWorker(observer, protocol);
    304   observer->SetWorker(worker.get());
    305   registry->default_client_observers_.push_back(observer);
    306   worker->StartSetAsDefault();
    307 }
    308 
    309 // ProtocolHandlerRegistry -----------------------------------------------------
    310 
    311 ProtocolHandlerRegistry::ProtocolHandlerRegistry(
    312     content::BrowserContext* context, Delegate* delegate)
    313     : context_(context),
    314       delegate_(delegate),
    315       enabled_(true),
    316       is_loading_(false),
    317       is_loaded_(false),
    318       io_thread_delegate_(new IOThreadDelegate(enabled_)){
    319 }
    320 
    321 bool ProtocolHandlerRegistry::SilentlyHandleRegisterHandlerRequest(
    322     const ProtocolHandler& handler) {
    323   if (handler.IsEmpty() || !CanSchemeBeOverridden(handler.protocol()))
    324     return true;
    325 
    326   if (!enabled() || IsRegistered(handler) || HasIgnoredEquivalent(handler))
    327     return true;
    328 
    329   if (AttemptReplace(handler))
    330     return true;
    331 
    332   return false;
    333 }
    334 
    335 void ProtocolHandlerRegistry::OnAcceptRegisterProtocolHandler(
    336     const ProtocolHandler& handler) {
    337   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    338   RegisterProtocolHandler(handler, USER);
    339   SetDefault(handler);
    340   Save();
    341   NotifyChanged();
    342 }
    343 
    344 void ProtocolHandlerRegistry::OnDenyRegisterProtocolHandler(
    345     const ProtocolHandler& handler) {
    346   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    347   RegisterProtocolHandler(handler, USER);
    348   Save();
    349   NotifyChanged();
    350 }
    351 
    352 void ProtocolHandlerRegistry::OnIgnoreRegisterProtocolHandler(
    353     const ProtocolHandler& handler) {
    354   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    355   IgnoreProtocolHandler(handler, USER);
    356   Save();
    357   NotifyChanged();
    358 }
    359 
    360 bool ProtocolHandlerRegistry::AttemptReplace(const ProtocolHandler& handler) {
    361   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    362   ProtocolHandler old_default = GetHandlerFor(handler.protocol());
    363   bool make_new_handler_default = handler.IsSameOrigin(old_default);
    364   ProtocolHandlerList to_replace(GetReplacedHandlers(handler));
    365   if (to_replace.empty())
    366     return false;
    367   for (ProtocolHandlerList::iterator p = to_replace.begin();
    368        p != to_replace.end(); ++p) {
    369     RemoveHandler(*p);
    370   }
    371   if (make_new_handler_default) {
    372     OnAcceptRegisterProtocolHandler(handler);
    373   } else {
    374     InsertHandler(handler);
    375     NotifyChanged();
    376   }
    377   return true;
    378 }
    379 
    380 ProtocolHandlerRegistry::ProtocolHandlerList
    381 ProtocolHandlerRegistry::GetReplacedHandlers(
    382     const ProtocolHandler& handler) const {
    383   ProtocolHandlerList replaced_handlers;
    384   const ProtocolHandlerList* handlers = GetHandlerList(handler.protocol());
    385   if (!handlers)
    386     return replaced_handlers;
    387   for (ProtocolHandlerList::const_iterator p = handlers->begin();
    388        p != handlers->end(); p++) {
    389     if (handler.IsSameOrigin(*p)) {
    390       replaced_handlers.push_back(*p);
    391     }
    392   }
    393   return replaced_handlers;
    394 }
    395 
    396 void ProtocolHandlerRegistry::ClearDefault(const std::string& scheme) {
    397   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    398 
    399   default_handlers_.erase(scheme);
    400   BrowserThread::PostTask(
    401       BrowserThread::IO,
    402       FROM_HERE,
    403       base::Bind(&IOThreadDelegate::ClearDefault, io_thread_delegate_, scheme));
    404   Save();
    405   NotifyChanged();
    406 }
    407 
    408 bool ProtocolHandlerRegistry::IsDefault(
    409     const ProtocolHandler& handler) const {
    410   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    411   return GetHandlerFor(handler.protocol()) == handler;
    412 }
    413 
    414 void ProtocolHandlerRegistry::InstallDefaultsForChromeOS() {
    415 #if defined(OS_CHROMEOS)
    416   // Only chromeos has default protocol handlers at this point.
    417   AddPredefinedHandler(
    418       ProtocolHandler::CreateProtocolHandler(
    419           "mailto",
    420           GURL(l10n_util::GetStringUTF8(IDS_GOOGLE_MAILTO_HANDLER_URL))));
    421   AddPredefinedHandler(
    422       ProtocolHandler::CreateProtocolHandler(
    423           "webcal",
    424           GURL(l10n_util::GetStringUTF8(IDS_GOOGLE_WEBCAL_HANDLER_URL))));
    425 #else
    426   NOTREACHED();  // this method should only ever be called in chromeos.
    427 #endif
    428 }
    429 
    430 void ProtocolHandlerRegistry::InitProtocolSettings() {
    431   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    432 
    433   // Any further default additions to the table will get rejected from now on.
    434   is_loaded_ = true;
    435   is_loading_ = true;
    436 
    437   PrefService* prefs = user_prefs::UserPrefs::Get(context_);
    438   if (prefs->HasPrefPath(prefs::kCustomHandlersEnabled)) {
    439     if (prefs->GetBoolean(prefs::kCustomHandlersEnabled)) {
    440       Enable();
    441     } else {
    442       Disable();
    443     }
    444   }
    445 
    446   RegisterProtocolHandlersFromPref(prefs::kPolicyRegisteredProtocolHandlers,
    447                                    POLICY);
    448   RegisterProtocolHandlersFromPref(prefs::kRegisteredProtocolHandlers, USER);
    449   IgnoreProtocolHandlersFromPref(prefs::kPolicyIgnoredProtocolHandlers, POLICY);
    450   IgnoreProtocolHandlersFromPref(prefs::kIgnoredProtocolHandlers, USER);
    451 
    452   is_loading_ = false;
    453 
    454   // For each default protocol handler, check that we are still registered
    455   // with the OS as the default application.
    456   if (ShouldRemoveHandlersNotInOS()) {
    457     for (ProtocolHandlerMap::const_iterator p = default_handlers_.begin();
    458          p != default_handlers_.end(); ++p) {
    459       ProtocolHandler handler = p->second;
    460       DefaultClientObserver* observer = delegate_->CreateShellObserver(this);
    461       scoped_refptr<ShellIntegration::DefaultProtocolClientWorker> worker;
    462       worker = delegate_->CreateShellWorker(observer, handler.protocol());
    463       observer->SetWorker(worker.get());
    464       default_client_observers_.push_back(observer);
    465       worker->StartCheckIsDefault();
    466     }
    467   }
    468 }
    469 
    470 int ProtocolHandlerRegistry::GetHandlerIndex(const std::string& scheme) const {
    471   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    472   const ProtocolHandler& handler = GetHandlerFor(scheme);
    473   if (handler.IsEmpty())
    474     return -1;
    475   const ProtocolHandlerList* handlers = GetHandlerList(scheme);
    476   if (!handlers)
    477     return -1;
    478 
    479   ProtocolHandlerList::const_iterator p;
    480   int i;
    481   for (i = 0, p = handlers->begin(); p != handlers->end(); ++p, ++i) {
    482     if (*p == handler)
    483       return i;
    484   }
    485   return -1;
    486 }
    487 
    488 ProtocolHandlerRegistry::ProtocolHandlerList
    489 ProtocolHandlerRegistry::GetHandlersFor(
    490     const std::string& scheme) const {
    491   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    492   ProtocolHandlerMultiMap::const_iterator p = protocol_handlers_.find(scheme);
    493   if (p == protocol_handlers_.end()) {
    494     return ProtocolHandlerList();
    495   }
    496   return p->second;
    497 }
    498 
    499 ProtocolHandlerRegistry::ProtocolHandlerList
    500 ProtocolHandlerRegistry::GetIgnoredHandlers() {
    501   return ignored_protocol_handlers_;
    502 }
    503 
    504 void ProtocolHandlerRegistry::GetRegisteredProtocols(
    505     std::vector<std::string>* output) const {
    506   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    507   ProtocolHandlerMultiMap::const_iterator p;
    508   for (p = protocol_handlers_.begin(); p != protocol_handlers_.end(); ++p) {
    509     if (!p->second.empty())
    510       output->push_back(p->first);
    511   }
    512 }
    513 
    514 bool ProtocolHandlerRegistry::CanSchemeBeOverridden(
    515     const std::string& scheme) const {
    516   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    517   const ProtocolHandlerList* handlers = GetHandlerList(scheme);
    518   // If we already have a handler for this scheme, we can add more.
    519   if (handlers != NULL && !handlers->empty())
    520     return true;
    521   // Don't override a scheme if it already has an external handler.
    522   return !delegate_->IsExternalHandlerRegistered(scheme);
    523 }
    524 
    525 bool ProtocolHandlerRegistry::IsRegistered(
    526     const ProtocolHandler& handler) const {
    527   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    528   const ProtocolHandlerList* handlers = GetHandlerList(handler.protocol());
    529   if (!handlers) {
    530     return false;
    531   }
    532   return std::find(handlers->begin(), handlers->end(), handler) !=
    533       handlers->end();
    534 }
    535 
    536 bool ProtocolHandlerRegistry::IsRegisteredByUser(
    537     const ProtocolHandler& handler) {
    538   return HandlerExists(handler, &user_protocol_handlers_);
    539 }
    540 
    541 bool ProtocolHandlerRegistry::HasPolicyRegisteredHandler(
    542     const std::string& scheme) {
    543   return (policy_protocol_handlers_.find(scheme) !=
    544           policy_protocol_handlers_.end());
    545 }
    546 
    547 bool ProtocolHandlerRegistry::IsIgnored(const ProtocolHandler& handler) const {
    548   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    549   ProtocolHandlerList::const_iterator i;
    550   for (i = ignored_protocol_handlers_.begin();
    551        i != ignored_protocol_handlers_.end(); ++i) {
    552     if (*i == handler) {
    553       return true;
    554     }
    555   }
    556   return false;
    557 }
    558 
    559 bool ProtocolHandlerRegistry::HasRegisteredEquivalent(
    560     const ProtocolHandler& handler) const {
    561   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    562   const ProtocolHandlerList* handlers = GetHandlerList(handler.protocol());
    563   if (!handlers) {
    564     return false;
    565   }
    566   ProtocolHandlerList::const_iterator i;
    567   for (i = handlers->begin(); i != handlers->end(); ++i) {
    568     if (handler.IsEquivalent(*i)) {
    569       return true;
    570     }
    571   }
    572   return false;
    573 }
    574 
    575 bool ProtocolHandlerRegistry::HasIgnoredEquivalent(
    576     const ProtocolHandler& handler) const {
    577   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    578   ProtocolHandlerList::const_iterator i;
    579   for (i = ignored_protocol_handlers_.begin();
    580        i != ignored_protocol_handlers_.end(); ++i) {
    581     if (handler.IsEquivalent(*i)) {
    582       return true;
    583     }
    584   }
    585   return false;
    586 }
    587 
    588 void ProtocolHandlerRegistry::RemoveIgnoredHandler(
    589     const ProtocolHandler& handler) {
    590   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    591   bool should_notify = false;
    592   if (HandlerExists(handler, ignored_protocol_handlers_) &&
    593       HandlerExists(handler, user_ignored_protocol_handlers_)) {
    594     EraseHandler(handler, &user_ignored_protocol_handlers_);
    595     Save();
    596     if (!HandlerExists(handler, policy_ignored_protocol_handlers_)) {
    597       EraseHandler(handler, &ignored_protocol_handlers_);
    598       should_notify = true;
    599     }
    600   }
    601   if (should_notify)
    602     NotifyChanged();
    603 }
    604 
    605 bool ProtocolHandlerRegistry::IsHandledProtocol(
    606     const std::string& scheme) const {
    607   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    608   return enabled_ && !GetHandlerFor(scheme).IsEmpty();
    609 }
    610 
    611 void ProtocolHandlerRegistry::RemoveHandler(
    612     const ProtocolHandler& handler) {
    613   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    614   ProtocolHandlerList& handlers = protocol_handlers_[handler.protocol()];
    615   bool erase_success = false;
    616   if (HandlerExists(handler, handlers) &&
    617       HandlerExists(handler, &user_protocol_handlers_)) {
    618     EraseHandler(handler, &user_protocol_handlers_);
    619     erase_success = true;
    620     if (!HandlerExists(handler, &policy_protocol_handlers_))
    621       EraseHandler(handler, &protocol_handlers_);
    622   }
    623   ProtocolHandlerMap::iterator q = default_handlers_.find(handler.protocol());
    624   if (erase_success && q != default_handlers_.end() && q->second == handler) {
    625     // Make the new top handler in the list the default.
    626     if (!handlers.empty()) {
    627       // NOTE We pass a copy because SetDefault() modifies handlers.
    628       SetDefault(ProtocolHandler(handlers[0]));
    629     } else {
    630       BrowserThread::PostTask(
    631           BrowserThread::IO, FROM_HERE,
    632           base::Bind(&IOThreadDelegate::ClearDefault, io_thread_delegate_,
    633                      q->second.protocol()));
    634 
    635       default_handlers_.erase(q);
    636     }
    637   }
    638 
    639   if (erase_success && !IsHandledProtocol(handler.protocol())) {
    640     delegate_->DeregisterExternalHandler(handler.protocol());
    641   }
    642   Save();
    643   if (erase_success)
    644     NotifyChanged();
    645 }
    646 
    647 void ProtocolHandlerRegistry::RemoveDefaultHandler(const std::string& scheme) {
    648   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    649   ProtocolHandler current_default = GetHandlerFor(scheme);
    650   if (!current_default.IsEmpty())
    651     RemoveHandler(current_default);
    652 }
    653 
    654 const ProtocolHandler& ProtocolHandlerRegistry::GetHandlerFor(
    655     const std::string& scheme) const {
    656   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    657   return LookupHandler(default_handlers_, scheme);
    658 }
    659 
    660 void ProtocolHandlerRegistry::Enable() {
    661   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    662   if (enabled_) {
    663     return;
    664   }
    665   enabled_ = true;
    666   BrowserThread::PostTask(
    667       BrowserThread::IO,
    668       FROM_HERE,
    669       base::Bind(&IOThreadDelegate::Enable, io_thread_delegate_));
    670 
    671   ProtocolHandlerMap::const_iterator p;
    672   for (p = default_handlers_.begin(); p != default_handlers_.end(); ++p) {
    673     delegate_->RegisterExternalHandler(p->first);
    674   }
    675   Save();
    676   NotifyChanged();
    677 }
    678 
    679 void ProtocolHandlerRegistry::Disable() {
    680   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    681   if (!enabled_) {
    682     return;
    683   }
    684   enabled_ = false;
    685   BrowserThread::PostTask(
    686       BrowserThread::IO,
    687       FROM_HERE,
    688       base::Bind(&IOThreadDelegate::Disable, io_thread_delegate_));
    689 
    690   ProtocolHandlerMap::const_iterator p;
    691   for (p = default_handlers_.begin(); p != default_handlers_.end(); ++p) {
    692     delegate_->DeregisterExternalHandler(p->first);
    693   }
    694   Save();
    695   NotifyChanged();
    696 }
    697 
    698 void ProtocolHandlerRegistry::Shutdown() {
    699   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    700   delegate_.reset(NULL);
    701   // We free these now in case there are any outstanding workers running. If
    702   // we didn't free them they could respond to workers and try to update the
    703   // protocol handler registry after it was deleted.
    704   // Observers remove themselves from this list when they are deleted; so
    705   // we delete the last item until none are left in the list.
    706   while (!default_client_observers_.empty()) {
    707     delete default_client_observers_.back();
    708   }
    709 }
    710 
    711 // static
    712 void ProtocolHandlerRegistry::RegisterProfilePrefs(
    713     user_prefs::PrefRegistrySyncable* registry) {
    714   registry->RegisterListPref(prefs::kRegisteredProtocolHandlers,
    715                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    716   registry->RegisterListPref(prefs::kIgnoredProtocolHandlers,
    717                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    718   registry->RegisterListPref(prefs::kPolicyRegisteredProtocolHandlers,
    719                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    720   registry->RegisterListPref(prefs::kPolicyIgnoredProtocolHandlers,
    721                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    722   registry->RegisterBooleanPref(
    723       prefs::kCustomHandlersEnabled,
    724       true,
    725       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    726 }
    727 
    728 ProtocolHandlerRegistry::~ProtocolHandlerRegistry() {
    729   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    730   DCHECK(default_client_observers_.empty());
    731 }
    732 
    733 void ProtocolHandlerRegistry::PromoteHandler(const ProtocolHandler& handler) {
    734   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    735   DCHECK(IsRegistered(handler));
    736   ProtocolHandlerMultiMap::iterator p =
    737       protocol_handlers_.find(handler.protocol());
    738   ProtocolHandlerList& list = p->second;
    739   list.erase(std::find(list.begin(), list.end(), handler));
    740   list.insert(list.begin(), handler);
    741 }
    742 
    743 void ProtocolHandlerRegistry::Save() {
    744   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    745   if (is_loading_) {
    746     return;
    747   }
    748   scoped_ptr<base::Value> registered_protocol_handlers(
    749       EncodeRegisteredHandlers());
    750   scoped_ptr<base::Value> ignored_protocol_handlers(EncodeIgnoredHandlers());
    751   PrefService* prefs = user_prefs::UserPrefs::Get(context_);
    752 
    753   prefs->Set(prefs::kRegisteredProtocolHandlers,
    754       *registered_protocol_handlers);
    755   prefs->Set(prefs::kIgnoredProtocolHandlers,
    756       *ignored_protocol_handlers);
    757   prefs->SetBoolean(prefs::kCustomHandlersEnabled, enabled_);
    758 }
    759 
    760 const ProtocolHandlerRegistry::ProtocolHandlerList*
    761 ProtocolHandlerRegistry::GetHandlerList(
    762     const std::string& scheme) const {
    763   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    764   ProtocolHandlerMultiMap::const_iterator p = protocol_handlers_.find(scheme);
    765   if (p == protocol_handlers_.end()) {
    766     return NULL;
    767   }
    768   return &p->second;
    769 }
    770 
    771 void ProtocolHandlerRegistry::SetDefault(const ProtocolHandler& handler) {
    772   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    773   ProtocolHandlerMap::const_iterator p = default_handlers_.find(
    774       handler.protocol());
    775   // If we're not loading, and we are setting a default for a new protocol,
    776   // register with the OS.
    777   if (!is_loading_ && p == default_handlers_.end())
    778       delegate_->RegisterWithOSAsDefaultClient(handler.protocol(), this);
    779   default_handlers_.erase(handler.protocol());
    780   default_handlers_.insert(std::make_pair(handler.protocol(), handler));
    781   PromoteHandler(handler);
    782   BrowserThread::PostTask(
    783       BrowserThread::IO,
    784       FROM_HERE,
    785       base::Bind(&IOThreadDelegate::SetDefault, io_thread_delegate_, handler));
    786 }
    787 
    788 void ProtocolHandlerRegistry::InsertHandler(const ProtocolHandler& handler) {
    789   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    790   ProtocolHandlerMultiMap::iterator p =
    791       protocol_handlers_.find(handler.protocol());
    792 
    793   if (p != protocol_handlers_.end()) {
    794     p->second.push_back(handler);
    795     return;
    796   }
    797 
    798   ProtocolHandlerList new_list;
    799   new_list.push_back(handler);
    800   protocol_handlers_[handler.protocol()] = new_list;
    801 }
    802 
    803 base::Value* ProtocolHandlerRegistry::EncodeRegisteredHandlers() {
    804   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    805   base::ListValue* protocol_handlers = new base::ListValue();
    806   for (ProtocolHandlerMultiMap::iterator i = user_protocol_handlers_.begin();
    807        i != user_protocol_handlers_.end();
    808        ++i) {
    809     for (ProtocolHandlerList::iterator j = i->second.begin();
    810          j != i->second.end(); ++j) {
    811       base::DictionaryValue* encoded = j->Encode();
    812       if (IsDefault(*j)) {
    813         encoded->Set("default", new base::FundamentalValue(true));
    814       }
    815       protocol_handlers->Append(encoded);
    816     }
    817   }
    818   return protocol_handlers;
    819 }
    820 
    821 base::Value* ProtocolHandlerRegistry::EncodeIgnoredHandlers() {
    822   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    823   base::ListValue* handlers = new base::ListValue();
    824   for (ProtocolHandlerList::iterator i =
    825            user_ignored_protocol_handlers_.begin();
    826        i != user_ignored_protocol_handlers_.end();
    827        ++i) {
    828     handlers->Append(i->Encode());
    829   }
    830   return handlers;
    831 }
    832 
    833 void ProtocolHandlerRegistry::NotifyChanged() {
    834   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    835   content::NotificationService::current()->Notify(
    836       chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
    837       content::Source<content::BrowserContext>(context_),
    838       content::NotificationService::NoDetails());
    839 }
    840 
    841 void ProtocolHandlerRegistry::RegisterProtocolHandler(
    842     const ProtocolHandler& handler,
    843     const HandlerSource source) {
    844   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    845   DCHECK(CanSchemeBeOverridden(handler.protocol()));
    846   DCHECK(!handler.IsEmpty());
    847   ProtocolHandlerMultiMap& map =
    848       (source == POLICY) ? policy_protocol_handlers_ : user_protocol_handlers_;
    849   ProtocolHandlerList& list = map[handler.protocol()];
    850   if (!HandlerExists(handler, list))
    851     list.push_back(handler);
    852   if (IsRegistered(handler)) {
    853     return;
    854   }
    855   if (enabled_ && !delegate_->IsExternalHandlerRegistered(handler.protocol()))
    856     delegate_->RegisterExternalHandler(handler.protocol());
    857   InsertHandler(handler);
    858 }
    859 
    860 std::vector<const base::DictionaryValue*>
    861 ProtocolHandlerRegistry::GetHandlersFromPref(const char* pref_name) const {
    862   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    863   std::vector<const base::DictionaryValue*> result;
    864   PrefService* prefs = user_prefs::UserPrefs::Get(context_);
    865   if (!prefs->HasPrefPath(pref_name)) {
    866     return result;
    867   }
    868 
    869   const base::ListValue* handlers = prefs->GetList(pref_name);
    870   if (handlers) {
    871     for (size_t i = 0; i < handlers->GetSize(); ++i) {
    872       const base::DictionaryValue* dict;
    873       if (!handlers->GetDictionary(i, &dict))
    874         continue;
    875       if (ProtocolHandler::IsValidDict(dict)) {
    876         result.push_back(dict);
    877       }
    878     }
    879   }
    880   return result;
    881 }
    882 
    883 void ProtocolHandlerRegistry::RegisterProtocolHandlersFromPref(
    884     const char* pref_name,
    885     const HandlerSource source) {
    886   std::vector<const base::DictionaryValue*> registered_handlers =
    887       GetHandlersFromPref(pref_name);
    888   for (std::vector<const base::DictionaryValue*>::const_iterator p =
    889            registered_handlers.begin();
    890        p != registered_handlers.end();
    891        ++p) {
    892     ProtocolHandler handler = ProtocolHandler::CreateProtocolHandler(*p);
    893     RegisterProtocolHandler(handler, source);
    894     bool is_default = false;
    895     if ((*p)->GetBoolean("default", &is_default) && is_default) {
    896       SetDefault(handler);
    897     }
    898   }
    899 }
    900 
    901 void ProtocolHandlerRegistry::IgnoreProtocolHandler(
    902     const ProtocolHandler& handler,
    903     const HandlerSource source) {
    904   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    905   ProtocolHandlerList& list = (source == POLICY)
    906                                   ? policy_ignored_protocol_handlers_
    907                                   : user_ignored_protocol_handlers_;
    908   if (!HandlerExists(handler, list))
    909     list.push_back(handler);
    910   if (HandlerExists(handler, ignored_protocol_handlers_))
    911     return;
    912   ignored_protocol_handlers_.push_back(handler);
    913 }
    914 
    915 void ProtocolHandlerRegistry::IgnoreProtocolHandlersFromPref(
    916     const char* pref_name,
    917     const HandlerSource source) {
    918   std::vector<const base::DictionaryValue*> ignored_handlers =
    919       GetHandlersFromPref(pref_name);
    920   for (std::vector<const base::DictionaryValue*>::const_iterator p =
    921            ignored_handlers.begin();
    922        p != ignored_handlers.end();
    923        ++p) {
    924     IgnoreProtocolHandler(ProtocolHandler::CreateProtocolHandler(*p), source);
    925   }
    926 }
    927 
    928 bool ProtocolHandlerRegistry::HandlerExists(const ProtocolHandler& handler,
    929                                             ProtocolHandlerMultiMap* map) {
    930   return HandlerExists(handler, (*map)[handler.protocol()]);
    931 }
    932 
    933 bool ProtocolHandlerRegistry::HandlerExists(const ProtocolHandler& handler,
    934                                             const ProtocolHandlerList& list) {
    935   return std::find(list.begin(), list.end(), handler) != list.end();
    936 }
    937 
    938 void ProtocolHandlerRegistry::EraseHandler(const ProtocolHandler& handler,
    939                                            ProtocolHandlerMultiMap* map) {
    940   EraseHandler(handler, &(*map)[handler.protocol()]);
    941 }
    942 
    943 void ProtocolHandlerRegistry::EraseHandler(const ProtocolHandler& handler,
    944                                            ProtocolHandlerList* list) {
    945   list->erase(std::find(list->begin(), list->end(), handler));
    946 }
    947 
    948 void ProtocolHandlerRegistry::AddPredefinedHandler(
    949     const ProtocolHandler& handler) {
    950   DCHECK(!is_loaded_);  // Must be called prior InitProtocolSettings.
    951   RegisterProtocolHandler(handler, USER);
    952   SetDefault(handler);
    953 }
    954 
    955 scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
    956 ProtocolHandlerRegistry::CreateJobInterceptorFactory() {
    957   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    958   // this is always created on the UI thread (in profile_io's
    959   // InitializeOnUIThread. Any method calls must be done
    960   // on the IO thread (this is checked).
    961   return scoped_ptr<JobInterceptorFactory>(
    962       new JobInterceptorFactory(io_thread_delegate_.get()));
    963 }
    964