Add DCHECKs to validate ProfileIOData's list of protocols.

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 <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 220 matching lines @@
 }
 
 // Delegate --------------------------------------------------------------------
 
 ProtocolHandlerRegistry::Delegate::~Delegate() {}
 
 void ProtocolHandlerRegistry::Delegate::RegisterExternalHandler(
     const std::string& protocol) {
   ChildProcessSecurityPolicy* policy =
     ChildProcessSecurityPolicy::GetInstance();
+  CHECK(CanSchemeBeOverridden(protocol));
   if (!policy->IsWebSafeScheme(protocol)) {
     policy->RegisterWebSafeScheme(protocol);
   }
 }
 
 void ProtocolHandlerRegistry::Delegate::DeregisterExternalHandler(
     const std::string& protocol) {
 }
 
-bool ProtocolHandlerRegistry::Delegate::IsExternalHandlerRegistered(
+bool ProtocolHandlerRegistry::Delegate::CanSchemeBeOverridden(
     const std::string& protocol) {
   // NOTE(koz): This function is safe to call from any thread, despite living
   // in ProfileIOData.
-  return ProfileIOData::IsHandledProtocol(protocol);
+  return !ProfileIOData::IsBuiltInProtocol(protocol);
 }
 
 scoped_refptr<shell_integration::DefaultProtocolClientWorker>
 ProtocolHandlerRegistry::Delegate::CreateShellWorker(
     const shell_integration::DefaultWebClientWorkerCallback& callback,
     const std::string& protocol) {
   return new shell_integration::DefaultProtocolClientWorker(callback, protocol);
 }
 
 void ProtocolHandlerRegistry::Delegate::RegisterWithOSAsDefaultClient(
@@ skipping 208 matching lines @@
   ProtocolHandlerMultiMap::const_iterator p;
   for (p = protocol_handlers_.begin(); p != protocol_handlers_.end(); ++p) {
     if (!p->second.empty())
       output->push_back(p->first);
   }
 }
 
 bool ProtocolHandlerRegistry::CanSchemeBeOverridden(
     const std::string& scheme) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  const ProtocolHandlerList* handlers = GetHandlerList(scheme);
-  // If we already have a handler for this scheme, we can add more.
-  if (handlers != NULL && !handlers->empty())
-    return true;
-  // Don't override a scheme if it already has an external handler.
-  return !delegate_->IsExternalHandlerRegistered(scheme);
+
+  // Don't override a scheme if it has an built-in handler (http, https, chrome-
+  // extension, etc).
+  return delegate_->CanSchemeBeOverridden(scheme);
 }
 
 bool ProtocolHandlerRegistry::IsRegistered(
     const ProtocolHandler& handler) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const ProtocolHandlerList* handlers = GetHandlerList(handler.protocol());
   if (!handlers) {
     return false;
   }
   return std::find(handlers->begin(), handlers->end(), handler) !=
@@ skipping 289 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
       content::Source<content::BrowserContext>(context_),
       content::NotificationService::NoDetails());
 }
 
 void ProtocolHandlerRegistry::RegisterProtocolHandler(
     const ProtocolHandler& handler,
     const HandlerSource source) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(CanSchemeBeOverridden(handler.protocol()));
+  if (!CanSchemeBeOverridden(handler.protocol())) {
+    NOTREACHED();
+    return;
+  }
+
   DCHECK(!handler.IsEmpty());
   ProtocolHandlerMultiMap& map =
       (source == POLICY) ? policy_protocol_handlers_ : user_protocol_handlers_;
   ProtocolHandlerList& list = map[handler.protocol()];
   if (!HandlerExists(handler, list))
     list.push_back(handler);
   if (IsRegistered(handler)) {
     return;
   }
-  if (enabled_ && !delegate_->IsExternalHandlerRegistered(handler.protocol()))
+  if (enabled_)
     delegate_->RegisterExternalHandler(handler.protocol());
   InsertHandler(handler);
 }
 
 std::vector<const base::DictionaryValue*>
 ProtocolHandlerRegistry::GetHandlersFromPref(const char* pref_name) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::vector<const base::DictionaryValue*> result;
   PrefService* prefs = user_prefs::UserPrefs::Get(context_);
   if (!prefs->HasPrefPath(pref_name)) {
@@ skipping 105 matching lines @@
 
 std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 ProtocolHandlerRegistry::CreateJobInterceptorFactory() {
   DCHECK_CURRENTLY_ON(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 std::unique_ptr<JobInterceptorFactory>(
       new JobInterceptorFactory(io_thread_delegate_.get()));
 }