Fix the handling of user gestures for external protocol handler dialogs.

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/logging.h"
@@ skipping 180 matching lines @@
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 
   StreamsPrivateAPI* streams_private = StreamsPrivateAPI::Get(profile);
   if (!streams_private)
     return;
   streams_private->ExecuteMimeTypeHandler(
       extension_id, web_contents, stream.Pass(), expected_content_size);
 }
 
-void LaunchURL(const GURL& url, int render_process_id, int render_view_id) {
+void LaunchURL(const GURL& url, int render_process_id, int render_view_id,
+               bool user_gesture) {
   // If there is no longer a WebContents, the request may have raced with tab
   // closing. Don't fire the external request. (It may have been a prerender.)
   content::WebContents* web_contents =
       tab_util::GetWebContentsByID(render_process_id, render_view_id);
   if (!web_contents)
     return;
 
   // Do not launch external requests attached to unswapped prerenders.
   prerender::PrerenderContents* prerender_contents =
       prerender::PrerenderContents::FromWebContents(web_contents);
   if (prerender_contents) {
     prerender_contents->Destroy(prerender::FINAL_STATUS_UNSUPPORTED_SCHEME);
     prerender::ReportPrerenderExternalURL();
     return;
   }
 
+  scoped_ptr<ExternalProtocolHandler::ScopedUserGesture> scoped_gesture;
+  if (user_gesture)
+    scoped_gesture.reset(new ExternalProtocolHandler::ScopedUserGesture);

[mmenke, 2014/03/31 14:38:42]

Can't this just be put this logic in ExternalProtocolHandler, and then
ScopedUserGesture can be made private?  I don't think this class has any reason
or need to know about the details of what ExternalProtocolHandler does with the
user_gesture bool.

[meacer, 2014/03/31 18:32:30]

Passing the user gesture bit directly to the external protocol handler was the
initial idea, but it was invasive in other parts of the code so we ended up
running the external handler in the context of a user gesture instead.

[mmenke, 2014/03/31 18:38:40]

Do you mean putting the scoped_gesture in
ExternalProtocolHandler::LaunchUrlWithDelegate instead of here, or pushing the
scoped_gesture all the way down to where it's actually used?  I'd think the
former would be almost no more invasive than this, since it's only called in one
other place.

[meacer, 2014/03/31 19:34:00]

I meant pushing the user_gesture bit all the way down. In fact, if I put 
scoped_gesture inside LaunchUrlWithDelegate, then I can go one step further and
remove ScopedUserGesture altogether and pass user_gesture to GetBlockState
instead, which is where the gesture is checked.

kalman@: What do you think about removing ScopedUserGesture? The patch deltas
are almost the same, and it'll be more readable to just pass the user_gesture
bit all the way down and remove the ref counting.

   ExternalProtocolHandler::LaunchUrlWithDelegate(
       url, render_process_id, render_view_id,
       g_external_protocol_handler_delegate);
 }
 #endif  // !defined(OS_ANDROID)
 
 void AppendComponentUpdaterThrottles(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     ResourceType::Type resource_type,
@@ skipping 206 matching lines @@
   }
 }
 
 ResourceDispatcherHostLoginDelegate*
     ChromeResourceDispatcherHostDelegate::CreateLoginDelegate(
         net::AuthChallengeInfo* auth_info, net::URLRequest* request) {
   return CreateLoginPrompt(auth_info, request);
 }
 
 bool ChromeResourceDispatcherHostDelegate::HandleExternalProtocol(
-    const GURL& url, int child_id, int route_id) {
+    const GURL& url,
+    int child_id,
+    int route_id,
+    bool initiated_by_user_gesture) {
 #if defined(OS_ANDROID)
   // Android use a resource throttle to handle external as well as internal
   // protocols.
   return false;
 #else
 
   ExtensionRendererState::WebViewInfo info;
   if (ExtensionRendererState::GetInstance()->GetWebViewInfo(child_id,
                                                             route_id,
                                                             &info)) {
     return false;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&LaunchURL, url, child_id, route_id));
+      base::Bind(&LaunchURL, url, child_id, route_id,
+                 initiated_by_user_gesture));
   return true;
 #endif
 }
 
 void ChromeResourceDispatcherHostDelegate::AppendStandardResourceThrottles(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     ResourceType::Type resource_type,
     ScopedVector<content::ResourceThrottle>* throttles) {
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
@@ skipping 211 matching lines @@
                                        url_request->GetTotalReceivedBytes()));
   }
 }
 
 // static
 void ChromeResourceDispatcherHostDelegate::
     SetExternalProtocolHandlerDelegateForTesting(
     ExternalProtocolHandler::Delegate* delegate) {
   g_external_protocol_handler_delegate = delegate;
 }