Add external protocol dialog for Linux....

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>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_process_impl.h"
 #include "chrome/common/platform_util.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/pref_names.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/escape.h"
 
-#if defined(OS_WIN)
-#include "chrome/browser/views/external_protocol_dialog.h"
-#endif
-
 // static
 void ExternalProtocolHandler::PrepopulateDictionary(DictionaryValue* win_pref) {
   static bool is_warm = false;
   if (is_warm)
     return;
   is_warm = true;
 
   static const wchar_t* const denied_schemes[] = {
     L"afp",
     L"data",
@@ skipping 72 matching lines @@
                                         int render_process_host_id,
                                         int tab_contents_id) {
   // 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 defined(OS_WIN)
   if (block_state == UNKNOWN) {
-    std::wstring command = ExternalProtocolDialog::GetApplicationForProtocol(
-                               escaped_url);
-    if (command.empty()) {
-      // ShellExecute won't do anything. Don't bother warning the user.
-      return;
-    }
-
+#if !defined(OS_MACOSX)
     // Ask the user if they want to allow the protocol. This will call
     // LaunchUrlWithoutSecurityCheck if the user decides to accept the protocol.
-    ExternalProtocolDialog::RunExternalProtocolDialog(escaped_url,
-                                                      command,
-                                                      render_process_host_id,
-                                                      tab_contents_id);
+    RunExternalProtocolDialog(escaped_url,
+                              render_process_host_id,
+                              tab_contents_id);
+#endif
+    // For now, allow only whitelisted protocols to fire on Mac.
+    // See http://crbug.com/15546.
     return;
   }
-#else
-  // For now, allow only whitelisted protocols to fire.
-  // TODO(port): implement dialog for Mac/Linux.
-  // See http://code.google.com/p/chromium/issues/detail?id=20731
-  // and http://code.google.com/p/chromium/issues/detail?id=15546.
-  if (block_state == UNKNOWN)
-    return;
-#endif
 
-  // Otherwise the protocol is white-listed, so go ahead and launch.
+  LaunchUrlWithoutSecurityCheck(escaped_url);
+}
+
+// static
+void ExternalProtocolHandler::LaunchUrlWithoutSecurityCheck(const GURL& url) {
 #if defined(OS_MACOSX)
   // This must run on the main thread on OS X.
-  LaunchUrlWithoutSecurityCheck(escaped_url);
+  platform_util::OpenExternal(url);
 #else
   // Otherwise put this work on the file thread. On Windows ShellExecute may
   // block for a significant amount of time, and it shouldn't hurt on Linux.
   MessageLoop* loop = g_browser_process->file_thread()->message_loop();
   if (loop == NULL) {
     return;
   }
 
   loop->PostTask(FROM_HERE,
-      NewRunnableFunction(
-          &ExternalProtocolHandler::LaunchUrlWithoutSecurityCheck,
-          escaped_url));
+      NewRunnableFunction(&platform_util::OpenExternal, url));
 #endif
 }
 
 // static
-void ExternalProtocolHandler::LaunchUrlWithoutSecurityCheck(const GURL& url) {
-  platform_util::OpenExternal(url);
-}
-
-// static
 void ExternalProtocolHandler::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kExcludedSchemes);
 }