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),
+      locking_defaults_(false) {
+}
+
+void ProtocolHandlerRegistry::InstallSystemDefaultHandlers() {
+#if defined(OS_CHROMEOS)
+  ProtocolHandler mail_handler = ProtocolHandler::CreateProtocolHandler(
+      std::string("mailto"),
+      GURL("https://mail.google.com/mail/?extsrc=mailto&url=%s"),
+      UTF8ToUTF16(std::string("Google.com Mail")));
+  RegisterProtocolHandler(mail_handler);
+  SetDefault(mail_handler);
+  ProtocolHandler cal_handler = ProtocolHandler::CreateProtocolHandler(
+      std::string("webcal"),
+      GURL("https://www.google.com/calendar/render?cid=%s"),
+      UTF8ToUTF16(std::string("Google Calendar")));
+  RegisterProtocolHandler(cal_handler);
+  SetDefault(cal_handler);
+#endif
+  locking_defaults_ = true;
+}
+
+bool ProtocolHandlerRegistry::IsFixedHandler(
+    const std::string& scheme) const {
+#if defined (OS_CHROMEOS)
+  return (locking_defaults_ && (scheme == "mailto" || scheme == "webcal"));
+#else
+  return false;
+#endif
 }
 
 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() {
+  // We add our default handlers only the first time we come here.
+  // On the next call the defaults will be locked.
+  if (!locking_defaults_)
+    InstallSystemDefaultHandlers();
+
   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 45 matching lines @@
   scoped_ptr<Value> enabled(Value::CreateBooleanValue(enabled_));
   profile_->GetPrefs()->Set(prefs::kRegisteredProtocolHandlers,
       *registered_protocol_handlers);
   profile_->GetPrefs()->Set(prefs::kIgnoredProtocolHandlers,
       *ignored_protocol_handlers);
   profile_->GetPrefs()->Set(prefs::kCustomHandlersEnabled, *enabled);
 }
 
 bool ProtocolHandlerRegistry::CanSchemeBeOverridden(
     const std::string& scheme) const {
+  if (IsFixedHandler(scheme))

[benwells, 2012/04/20 00:25:05]

If I understand this change correctly, ChromeOS users won't be able to ever
register other handlers. Is that what we want? Could we have the standard
handlers always present but let users add others and set them to be the default?

[Mr4D (OOO till 08-26), 2012/04/20 13:44:41]

There are no 'apps' which can do these things. As such the assigned bug said
that this should be set. I also checked with UX team and they agreed. So, yes,
this is what we want.

That all said: Someone might argue that since the user does not even get the
option to overwrite this scheme, this will probably never be hit. But in this
case I am better safe then sorry since if the user would replace the item he
would have no way back..

[benwells, 2012/04/20 21:55:10]

registerProtocolHandler is a web standard, and can be used by any web site. This
change will disable it for gmail and calendar, with users being fixed onto our
hard-coded defaults.

I don't get a sense from the bug that's intended. What I think should happen is
that ChromeOS has default handlers which can't be removed, but which the user
can override (i.e. set another default). If you do that the user won't get
prompted about gmail and google calendar as they will always be registered.

BTW I really like this change, providing we keep registerProtoclHandler working.
Can we also remove the hardcoded ChromeOS redirection for mailto: and webcal:
that is somewhere else in the code (I can't remember where, external_handlers.cc
perhaps)? It shouldn't be necessary with your change.

[Mr4D (OOO till 08-26), 2012/04/21 00:27:28]

Okay, fine. I will remove it then. :) (Who am I messing around with web
standards?).

However - this also means that I have to reverse a few other things. I think the
only remaining thing then is that we want to pre-populate the default (if there
isn't one yet).

For the other request: I have found a non ChromeOS specific string substitution
(register_protocol_handler_infobar_delagate.cc). Furthermore I have found one
thing in platform_util_chromeos.cc where the scheme 'mailto' gets intercepted
and directed to gmail. But after staring on various portions of the code I am
not sure how this is used (e.g. LaunchUrlWithoutSecurityCheck). So I'd rather
not touch that for the moment.

+    return false;
   DCHECK(BrowserThread::CurrentlyOn(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);
 }
 
 void ProtocolHandlerRegistry::GetRegisteredProtocols(
     std::vector<std::string>* output) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProtocolHandlerMultiMap::const_iterator p;
   for (p = protocol_handlers_.begin(); p != protocol_handlers_.end(); ++p) {
-    if (!p->second.empty())
+    // We don't want the settings dialog to show 'internal defaults'.
+    if (!p->second.empty() && !IsFixedHandler(p->first))
       output->push_back(p->first);
   }
 }
 
 void ProtocolHandlerRegistry::RemoveIgnoredHandler(
     const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   bool should_notify = false;
   ProtocolHandlerList::iterator p = std::find(
       ignored_protocol_handlers_.begin(), ignored_protocol_handlers_.end(),
@@ skipping 416 matching lines @@
     }
   } else {
     NOTREACHED();
   }
 }
 
 void ProtocolHandlerRegistry::DefaultClientObserver::SetWorker(
     ShellIntegration::DefaultProtocolClientWorker* worker) {
   worker_ = worker;
 }