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

extensions/browser/extension_function_dispatcher.cc

 // Copyright 2014 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 "extensions/browser/extension_function_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 74 matching lines @@
   if (process)
     base::KillProcess(process, content::RESULT_CODE_KILLED_BAD_MESSAGE, false);
 }
 
 void CommonResponseCallback(IPC::Sender* ipc_sender,
                             int routing_id,
                             base::ProcessHandle peer_process,
                             int request_id,
                             ExtensionFunction::ResponseType type,
                             const base::ListValue& results,
-                            const std::string& error) {
+                            const std::string& error,
+                            const bool user_gesture) {
   DCHECK(ipc_sender);
 
   if (type == ExtensionFunction::BAD_MESSAGE) {
     // The renderer has done validation before sending extension api requests.
     // Therefore, we should never receive a request that is invalid in a way
     // that JSON validation in the renderer should have caught. It could be an
     // attacker trying to exploit the browser, so we crash the renderer instead.
     LOG(ERROR) <<
         "Terminating renderer because of malformed extension message.";
     if (content::RenderProcessHost::run_renderer_in_process()) {
       // In single process mode it is better if we don't suicide but just crash.
       CHECK(false);
     } else {
       KillBadMessageSender(peer_process);
     }
 
     return;
   }
 
   ipc_sender->Send(new ExtensionMsg_Response(
       routing_id, request_id, type == ExtensionFunction::SUCCEEDED, results,
-      error));
+      error, user_gesture));
 }
 
 void IOThreadResponseCallback(
     const base::WeakPtr<ExtensionMessageFilter>& ipc_sender,
     int routing_id,
     int request_id,
     ExtensionFunction::ResponseType type,
     const base::ListValue& results,
-    const std::string& error) {
+    const std::string& error,
+    const bool user_gesture) {
   if (!ipc_sender.get())
     return;
 
   CommonResponseCallback(ipc_sender.get(),
                          routing_id,
                          ipc_sender->PeerHandle(),
                          request_id,
                          type,
                          results,
-                         error);
+                         error,
+                         user_gesture);
 }
 
 }  // namespace
 
 class ExtensionFunctionDispatcher::UIThreadResponseCallbackWrapper
     : public content::WebContentsObserver {
  public:
   UIThreadResponseCallbackWrapper(
       const base::WeakPtr<ExtensionFunctionDispatcher>& dispatcher,
       RenderViewHost* render_view_host)
@@ skipping 26 matching lines @@
     return base::Bind(
         &UIThreadResponseCallbackWrapper::OnExtensionFunctionCompleted,
         weak_ptr_factory_.GetWeakPtr(),
         request_id);
   }
 
  private:
   void OnExtensionFunctionCompleted(int request_id,
                                     ExtensionFunction::ResponseType type,
                                     const base::ListValue& results,
-                                    const std::string& error) {
+                                    const std::string& error,
+                                    const bool user_gesture) {
     CommonResponseCallback(
         render_view_host_, render_view_host_->GetRoutingID(),
         render_view_host_->GetProcess()->GetHandle(), request_id, type,
-        results, error);
+        results, error, user_gesture);
   }
 
   base::WeakPtr<ExtensionFunctionDispatcher> dispatcher_;
   content::RenderViewHost* render_view_host_;
   base::WeakPtrFactory<UIThreadResponseCallbackWrapper> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UIThreadResponseCallbackWrapper);
 };
 
 WindowController*
@@ skipping 301 matching lines @@
   function->set_source_tab_id(params.source_tab_id);
 
   return function;
 }
 
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     const ExtensionFunction::ResponseCallback& callback) {
   base::ListValue empty_list;
   callback.Run(ExtensionFunction::FAILED, empty_list,
-               "Access to extension API denied.");
+               "Access to extension API denied.", false);
 }
 
 }  // namespace extensions