Preventing our default handlers for ChromeOS to show up or confuse the user

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/scoped_ptr.h"
+#include "base/utf_string_conversions.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 "net/base/network_delegate.h"
 #include "net/url_request/url_request_redirect_job.h"
 
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 
 // ProtocolHandlerRegistry -----------------------------------------------------
 
 ProtocolHandlerRegistry::ProtocolHandlerRegistry(Profile* profile,
     Delegate* delegate)
     : profile_(profile),
       delegate_(delegate),
       enabled_(true),
       enabled_io_(enabled_),
-      is_loading_(false) {
+      is_loading_(false),
+      is_loaded_(false) {
 }
 
 ProtocolHandlerRegistry::~ProtocolHandlerRegistry() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(default_client_observers_.empty());
 }
 
 void ProtocolHandlerRegistry::Finalize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   delegate_.reset(NULL);
@@ skipping 139 matching lines @@
   // difference (http://crbug.com/88255).
   return false;
 #else
   return ShellIntegration::CanSetAsDefaultProtocolClient();
 #endif
 }
 
 } // namespace
 
 void ProtocolHandlerRegistry::Load() {
+  // 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));
@@ skipping 376 matching lines @@
 }
 
 void ProtocolHandlerRegistry::NotifyChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
       content::Source<Profile>(profile_),
       content::NotificationService::NoDetails());
 }
 
+void ProtocolHandlerRegistry::AddFixedHandler(const ProtocolHandler& handler) {

[DaveMoore, 2012/04/26 14:45:50]

The name "Fixed" handler seems wrong. Isn't it a Default handler?

[Mr4D (OOO till 08-26), 2012/04/26 16:34:37]

Done. In deed. The meaning of this has changed due to reviews. :)

[koz (OOO until 15th September), 2012/04/30 02:11:26]

No, fixed handler is right. "Default handler" is already a concept in this
class, so with this rename we now have SetDefault() and RemoveDefaultHanlder(),
both of which mean the handler that is invoked by default for a given protocol,
and this, AddDefaultHandler(), which is about registering "pre-installed"
handlers at Load() time.

Perhaps "preinstalled" handlers is a better name than fixed, but we shouldn't
overload the term "default" here.

(Looking at the comment in the final revision "// The installation of any
pre-defined protocol handlers.", maybe "predefined" is a better word?)

+  // If called after the load command was issued this function will fail.
+  DCHECK(!is_loaded_);
+  RegisterProtocolHandler(handler);
+  SetDefault(handler);
+}
+
 // IO thread methods -----------------------------------------------------------
 
 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());
@@ skipping 100 matching lines @@
     }
   } else {
     NOTREACHED();
   }
 }
 
 void ProtocolHandlerRegistry::DefaultClientObserver::SetWorker(
     ShellIntegration::DefaultProtocolClientWorker* worker) {
   worker_ = worker;
 }