Add the feature to retain the user gesture in the extension callback

chrome/renderer/extensions/request_sender.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/renderer/extensions/request_sender.h"
 
 #include "base/values.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/extension_messages.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
+#include "third_party/WebKit/public/web/WebUserGestureToken.h"
 
 namespace extensions {
 
 // Contains info relevant to a pending API request.
 struct PendingRequest {
  public :
-  PendingRequest(const std::string& name, RequestSender::Source* source)
-      : name(name), source(source) {
+  PendingRequest(const std::string& name,
+                 RequestSender::Source* source,
+                 blink::WebUserGestureToken token)
+      : name(name), source(source), token(token) {
   }
 
   std::string name;
   RequestSender::Source* source;
+  blink::WebUserGestureToken token;
 };
 
 RequestSender::ScopedTabID::ScopedTabID(RequestSender* request_sender,
                                         int tab_id)
     : request_sender_(request_sender),
       tab_id_(tab_id),
       previous_tab_id_(request_sender->source_tab_id_) {
   request_sender_->source_tab_id_ = tab_id;
 }
 
@@ skipping 54 matching lines @@
   }
 
   // TODO(koz): See if we can make this a CHECK.
   if (!dispatcher_->CheckContextAccessToExtensionAPI(name, context))
     return;
 
   GURL source_url;
   if (blink::WebFrame* webframe = context->web_frame())
     source_url = webframe->document().url();
 
-  InsertRequest(request_id, new PendingRequest(name, source));
+  InsertRequest(request_id, new PendingRequest(name, source,
+      blink::WebUserGestureIndicator::currentUserGestureToken()));
 
   ExtensionHostMsg_Request_Params params;
   params.name = name;
   params.arguments.Swap(value_args);
   params.extension_id = context->GetExtensionID();
   params.source_url = source_url;
   params.source_tab_id = source_tab_id_;
   params.request_id = request_id;
   params.has_callback = has_callback;
   params.user_gesture =
       blink::WebUserGestureIndicator::isProcessingUserGesture();
   if (for_io_thread) {
     renderview->Send(new ExtensionHostMsg_RequestForIOThread(
         renderview->GetRoutingID(), params));
   } else {
     renderview->Send(new ExtensionHostMsg_Request(
         renderview->GetRoutingID(), params));
   }
 }
 
 void RequestSender::HandleResponse(int request_id,
                                    bool success,
                                    const base::ListValue& response,
-                                   const std::string& error) {
+                                   const std::string& error,
+                                   bool user_gesture) {
   linked_ptr<PendingRequest> request = RemoveRequest(request_id);
 
   if (!request.get()) {
     // This can happen if a context is destroyed while a request is in flight.
     return;
   }
 
+  scoped_ptr<blink::WebScopedUserGesture> gesture;
+  if (user_gesture)
+    gesture.reset(new blink::WebScopedUserGesture(request->token));
+
   request->source->OnResponseReceived(request->name, request_id, success,
                                       response, error);
 }
 
 void RequestSender::InvalidateSource(Source* source) {
   for (PendingRequestMap::iterator it = pending_requests_.begin();
        it != pending_requests_.end();) {
     if (it->second->source == source)
       pending_requests_.erase(it++);
     else
       ++it;
   }
 }
 
 }  // namespace extensions