Fix an issue that external protocol in subframes are not handled on Android

chrome/browser/external_protocol/external_protocol_handler.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/external_protocol/external_protocol_handler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 42 matching lines @@
   if (!delegate)
     return ExternalProtocolHandler::GetBlockState(scheme);
 
   return delegate->GetBlockState(scheme);
 }
 
 void RunExternalProtocolDialogWithDelegate(
     const GURL& url,
     int render_process_host_id,
     int routing_id,
+    ui::PageTransition page_transition,
+    bool has_user_gesture,
     ExternalProtocolHandler::Delegate* delegate) {
   if (!delegate) {
-    ExternalProtocolHandler::RunExternalProtocolDialog(url,
-                                                       render_process_host_id,
-                                                       routing_id);
+    ExternalProtocolHandler::RunExternalProtocolDialog(
+        url, render_process_host_id, routing_id, page_transition,
+        has_user_gesture);
   } else {
-    delegate->RunExternalProtocolDialog(url, render_process_host_id,
-                                        routing_id);
+    delegate->RunExternalProtocolDialog(
+        url, render_process_host_id, routing_id, page_transition,
+        has_user_gesture);
   }
 }
 
 void LaunchUrlWithoutSecurityCheckWithDelegate(
     const GURL& url,
     int render_process_host_id,
     int tab_contents_id,
     ExternalProtocolHandler::Delegate* delegate) {
   if (!delegate) {
     ExternalProtocolHandler::LaunchUrlWithoutSecurityCheck(
         url, render_process_host_id, tab_contents_id);
   } else {
     delegate->LaunchUrlWithoutSecurityCheck(url);
   }
 }
 
 // When we are about to launch a URL with the default OS level application,
 // we check if that external application will be us. If it is we just ignore
 // the request.
 class ExternalDefaultProtocolObserver
     : public ShellIntegration::DefaultWebClientObserver {
  public:
   ExternalDefaultProtocolObserver(const GURL& escaped_url,
                                   int render_process_host_id,
                                   int tab_contents_id,
                                   bool prompt_user,
+                                  ui::PageTransition page_transition,
+                                  bool has_user_gesture,
                                   ExternalProtocolHandler::Delegate* delegate)
       : delegate_(delegate),
         escaped_url_(escaped_url),
         render_process_host_id_(render_process_host_id),
         tab_contents_id_(tab_contents_id),
-        prompt_user_(prompt_user) {}
+        prompt_user_(prompt_user),
+        page_transition_(page_transition),
+        has_user_gesture_(has_user_gesture) {}
 
   void SetDefaultWebClientUIState(
       ShellIntegration::DefaultWebClientUIState state) override {
     DCHECK(base::MessageLoopForUI::IsCurrent());
 
     // If we are still working out if we're the default, or we've found
     // out we definately are the default, we end here.
     if (state == ShellIntegration::STATE_PROCESSING) {
       return;
     }
 
     if (delegate_)
       delegate_->FinishedProcessingCheck();
 
     if (state == ShellIntegration::STATE_IS_DEFAULT) {
       if (delegate_)
         delegate_->BlockRequest();
       return;
     }
 
     // If we get here, either we are not the default or we cannot work out
     // what the default is, so we proceed.
     if (prompt_user_) {
       // Ask the user if they want to allow the protocol. This will call
       // LaunchUrlWithoutSecurityCheck if the user decides to accept the
       // protocol.
-      RunExternalProtocolDialogWithDelegate(escaped_url_,
-          render_process_host_id_, tab_contents_id_, delegate_);
+      RunExternalProtocolDialogWithDelegate(
+          escaped_url_, render_process_host_id_, tab_contents_id_,
+          page_transition_, has_user_gesture_, delegate_);
       return;
     }
 
     LaunchUrlWithoutSecurityCheckWithDelegate(
         escaped_url_, render_process_host_id_, tab_contents_id_, delegate_);
   }
 
   bool IsOwnedByWorker() override { return true; }
 
  private:
   ExternalProtocolHandler::Delegate* delegate_;
   GURL escaped_url_;
   int render_process_host_id_;
   int tab_contents_id_;
   bool prompt_user_;
+  ui::PageTransition page_transition_;

[sky, 2015/05/04 19:15:49]

nit: const on all of these.

[qinmin, 2015/05/04 19:31:52]

Done.

+  bool has_user_gesture_;
 };
 
 }  // namespace
 
 // static
 void ExternalProtocolHandler::PrepopulateDictionary(
     base::DictionaryValue* win_pref) {
   static bool is_warm = false;
   if (is_warm)
     return;
@@ skipping 89 matching lines @@
 
     if (state == UNKNOWN) {
       update_excluded_schemas->Remove(scheme, NULL);
     } else {
       update_excluded_schemas->SetBoolean(scheme, (state == BLOCK));
     }
   }
 }
 
 // static
-void ExternalProtocolHandler::LaunchUrlWithDelegate(const GURL& url,
-                                                    int render_process_host_id,
-                                                    int tab_contents_id,
-                                                    Delegate* delegate) {
+void ExternalProtocolHandler::LaunchUrlWithDelegate(
+    const GURL& url,
+    int render_process_host_id,
+    int tab_contents_id,
+    ui::PageTransition page_transition,
+    bool has_user_gesture,
+    Delegate* delegate) {
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   // Escape the input scheme to be sure that the command does not
   // have parameters unexpected by the external program.
   std::string escaped_url_string = net::EscapeExternalHandlerValue(url.spec());
   GURL escaped_url(escaped_url_string);
   BlockState block_state =
       GetBlockStateWithDelegate(escaped_url.scheme(), delegate);
   if (block_state == BLOCK) {
     if (delegate)
       delegate->BlockRequest();
     return;
   }
 
   g_accept_requests = false;
 
   // The worker creates tasks with references to itself and puts them into
   // message loops. When no tasks are left it will delete the observer and
   // eventually be deleted itself.
   ShellIntegration::DefaultWebClientObserver* observer =
       new ExternalDefaultProtocolObserver(url,
                                           render_process_host_id,
                                           tab_contents_id,
                                           block_state == UNKNOWN,
+                                          page_transition,
+                                          has_user_gesture,
                                           delegate);
   scoped_refptr<ShellIntegration::DefaultProtocolClientWorker> worker =
       CreateShellWorker(observer, escaped_url.scheme(), delegate);
 
   // Start the check process running. This will send tasks to the FILE thread
   // and when the answer is known will send the result back to the observer on
   // the UI thread.
   worker->StartCheckIsDefault();
 }
 
@@ skipping 14 matching lines @@
 // static
 void ExternalProtocolHandler::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kExcludedSchemes);
 }
 
 // static
 void ExternalProtocolHandler::PermitLaunchUrl() {
   DCHECK(base::MessageLoopForUI::IsCurrent());
   g_accept_requests = true;
 }