[Geolocation] Attach user gesture indicator to permission request call.

content/browser/browser_plugin/browser_plugin_guest.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 "content/browser/browser_plugin/browser_plugin_guest.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
@@ skipping 94 matching lines @@
 
  private:
   virtual ~DownloadRequest() {}
   base::Callback<void(bool)> callback_;
 };
 
 class BrowserPluginGuest::GeolocationRequest : public PermissionRequest {
  public:
   GeolocationRequest(const base::WeakPtr<BrowserPluginGuest>& guest,
                      GeolocationCallback callback,
-                     int bridge_id)
+                     int bridge_id,
+                     bool user_gesture)
                      : PermissionRequest(guest),
                        callback_(callback),
-                       bridge_id_(bridge_id) {
+                       bridge_id_(bridge_id),
+                       user_gesture_(user_gesture) {
     RecordAction(
         base::UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.Geolocation"));
   }
 
   virtual void RespondImpl(bool should_allow,
                            const std::string& user_input) OVERRIDE {
     WebContents* web_contents = guest_->embedder_web_contents();
     if (should_allow && web_contents) {
       // If renderer side embedder decides to allow gelocation, we need to check
       // if the app/embedder itself has geolocation access.
       BrowserContext* browser_context = web_contents->GetBrowserContext();
       if (browser_context) {
         GeolocationPermissionContext* geolocation_context =
             browser_context->GetGeolocationPermissionContext();
         if (geolocation_context) {
           base::Callback<void(bool)> geolocation_callback = base::Bind(
               &BrowserPluginGuest::SetGeolocationPermission,
               guest_,
               callback_,
               bridge_id_);
           geolocation_context->RequestGeolocationPermission(
               web_contents->GetRenderProcessHost()->GetID(),
               web_contents->GetRoutingID(),
               // The geolocation permission request here is not initiated
               // through WebGeolocationPermissionRequest. We are only interested
               // in the fact whether the embedder/app has geolocation
               // permission. Therefore we use an invalid |bridge_id|.
               -1 /* bridge_id */,
               web_contents->GetLastCommittedURL(),
+              user_gesture_,
               geolocation_callback);
           return;
         }
       }
     }
     guest_->SetGeolocationPermission(callback_, bridge_id_, false);
   }
 
  private:
   virtual ~GeolocationRequest() {}
   base::Callback<void(bool)> callback_;
   int bridge_id_;
+  bool user_gesture_;
 };
 
 class BrowserPluginGuest::MediaRequest : public PermissionRequest {
  public:
   MediaRequest(const base::WeakPtr<BrowserPluginGuest>& guest,
                const MediaStreamRequest& request,
                const MediaResponseCallback& callback)
                : PermissionRequest(guest),
                  request_(request),
                  callback_(callback) {
@@ skipping 880 matching lines @@
 }
 
 void BrowserPluginGuest::SetDelegate(BrowserPluginGuestDelegate* delegate) {
   DCHECK(!delegate_);
   delegate_.reset(delegate);
 }
 
 void BrowserPluginGuest::AskEmbedderForGeolocationPermission(
     int bridge_id,
     const GURL& requesting_frame,
+    bool user_gesture,
     const GeolocationCallback& callback) {
   base::DictionaryValue request_info;
   request_info.Set(browser_plugin::kURL,
                    base::Value::CreateStringValue(requesting_frame.spec()));
 
   int request_id =
       RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_GEOLOCATION,
                         new GeolocationRequest(weak_ptr_factory_.GetWeakPtr(),
                                                callback,
-                                               bridge_id),
+                                               bridge_id,
+                                               user_gesture),
                         request_info);
 
   DCHECK(bridge_id_to_request_id_map_.find(bridge_id) ==
          bridge_id_to_request_id_map_.end());
   bridge_id_to_request_id_map_[bridge_id] = request_id;
 }
 
 int BrowserPluginGuest::RemoveBridgeID(int bridge_id) {
   std::map<int, int>::iterator bridge_itr =
       bridge_id_to_request_id_map_.find(bridge_id);
@@ skipping 846 matching lines @@
                    base::Value::CreateStringValue(request_method));
   request_info.Set(browser_plugin::kURL, base::Value::CreateStringValue(url));
 
   RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_DOWNLOAD,
                     new DownloadRequest(weak_ptr_factory_.GetWeakPtr(),
                                         callback),
                     request_info);
 }
 
 }  // namespace content