External protocol dialog support for the Mac....

chrome/browser/external_protocol_handler.cc

 // Copyright (c) 2006-2008 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/external_protocol_handler.h"
 
 #include "build/build_config.h"
 
 #include <set>
 
@@ skipping 72 matching lines @@
     return BLOCK;
 
   if (scheme.length() == 1) {
     // We have a URL that looks something like:
     //   C:/WINDOWS/system32/notepad.exe
     // ShellExecuting this URL will cause the specified program to be executed.
     return BLOCK;
   }
 
   // Check the stored prefs.
-  // TODO(pkasting): http://b/119651 This kind of thing should go in the
+  // TODO(pkasting): http://b/1119651 This kind of thing should go in the
   // preferences on the profile, not in the local state.
   PrefService* pref = g_browser_process->local_state();
   if (pref) {  // May be NULL during testing.
     DictionaryValue* win_pref =
         pref->GetMutableDictionary(prefs::kExcludedSchemes);
     CHECK(win_pref);
 
     // Warm up the dictionary if needed.
     PrepopulateDictionary(win_pref);
 
     bool should_block;
     if (win_pref->GetBoolean(scheme, &should_block))
       return should_block ? BLOCK : DONT_BLOCK;
   }
 
   return UNKNOWN;
 }
 
 // static
+void ExternalProtocolHandler::SetBlockState(const std::wstring& scheme,
+                                            BlockState state) {
+  // Set in the stored prefs.
+  // TODO(pkasting): http://b/1119651 This kind of thing should go in the
+  // preferences on the profile, not in the local state.
+  PrefService* pref = g_browser_process->local_state();
+  if (pref) {  // May be NULL during testing.
+    DictionaryValue* win_pref =
+        pref->GetMutableDictionary(prefs::kExcludedSchemes);
+    CHECK(win_pref);
+
+    if (state == UNKNOWN)
+      win_pref->Remove(scheme, NULL);
+    else
+      win_pref->SetBoolean(scheme, state == BLOCK ? true : false);
+  }
+}
+
+// static
 void ExternalProtocolHandler::LaunchUrl(const GURL& url,
                                         int render_process_host_id,
                                         int tab_contents_id) {
   DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
 
   // Escape the input scheme to be sure that the command does not
   // have parameters unexpected by the external program.
   std::string escaped_url_string = EscapeExternalHandlerValue(url.spec());
   GURL escaped_url(escaped_url_string);
   BlockState block_state = GetBlockState(ASCIIToWide(escaped_url.scheme()));
   if (block_state == BLOCK)
     return;
 
   if (block_state == UNKNOWN) {
-#if defined(OS_WIN) || defined(TOOLKIT_GTK)
+#if defined(OS_WIN) || defined(TOOLKIT_GTK) || defined(OS_MACOSX)
     g_accept_requests = false;
     // Ask the user if they want to allow the protocol. This will call
     // LaunchUrlWithoutSecurityCheck if the user decides to accept the protocol.
     RunExternalProtocolDialog(escaped_url,
                               render_process_host_id,
                               tab_contents_id);
 #endif
-    // For now, allow only whitelisted protocols to fire on Mac and Linux/Views.
-    // See http://crbug.com/15546.
+    // For now, allow only whitelisted protocols to fire on Linux/Views.
+    // See http://crbug.com/23853 .
     return;
   }
 
   LaunchUrlWithoutSecurityCheck(escaped_url);
 }
 
 // static
 void ExternalProtocolHandler::LaunchUrlWithoutSecurityCheck(const GURL& url) {
 #if defined(OS_MACOSX)
   // This must run on the UI thread on OS X.
@@ skipping 14 matching lines @@
 // static
 void ExternalProtocolHandler::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kExcludedSchemes);
 }
 
 // static
 void ExternalProtocolHandler::OnUserGesture() {
   DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
   g_accept_requests = true;
 }