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

chrome/browser/geolocation/chrome_geolocation_permission_context.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/geolocation/chrome_geolocation_permission_context.h"
 
 #include <functional>
 #include <string>
 #include <vector>
 
@@ skipping 23 matching lines @@
 
 using extensions::APIPermission;
 using extensions::ExtensionRegistry;
 
 class GeolocationPermissionRequest : public PermissionBubbleRequest {
  public:
   GeolocationPermissionRequest(
       ChromeGeolocationPermissionContext* context,
       const PermissionRequestID& id,
       const GURL& requesting_frame,
+      bool user_gesture,
       base::Callback<void(bool)> callback,
       const std::string& display_languages);
   virtual ~GeolocationPermissionRequest();
 
   // PermissionBubbleDelegate:
   virtual int GetIconID() const OVERRIDE;
   virtual base::string16 GetMessageText() const OVERRIDE;
   virtual base::string16 GetMessageTextFragment() const OVERRIDE;
   virtual bool HasUserGesture() const OVERRIDE;
   virtual GURL GetRequestingHostname() const OVERRIDE;
   virtual void PermissionGranted() OVERRIDE;
   virtual void PermissionDenied() OVERRIDE;
   virtual void Cancelled() OVERRIDE;
   virtual void RequestFinished() OVERRIDE;
 
  private:
   ChromeGeolocationPermissionContext* context_;
   PermissionRequestID id_;
   GURL requesting_frame_;
+  bool user_gesture_;
   base::Callback<void(bool)> callback_;
   std::string display_languages_;
 };
 
 GeolocationPermissionRequest::GeolocationPermissionRequest(
     ChromeGeolocationPermissionContext* context,
     const PermissionRequestID& id,
     const GURL& requesting_frame,
+    bool user_gesture,
     base::Callback<void(bool)> callback,
     const std::string& display_languages)
     : context_(context),
       id_(id),
       requesting_frame_(requesting_frame),
+      user_gesture_(user_gesture),
       callback_(callback),
       display_languages_(display_languages) {}
 
 GeolocationPermissionRequest::~GeolocationPermissionRequest() {}
 
 int GeolocationPermissionRequest::GetIconID() const {
   return IDR_INFOBAR_GEOLOCATION;
 }
 
 base::string16 GeolocationPermissionRequest::GetMessageText() const {
   return l10n_util::GetStringFUTF16(IDS_GEOLOCATION_INFOBAR_QUESTION,
       net::FormatUrl(requesting_frame_, display_languages_));
 }
 
 base::string16 GeolocationPermissionRequest::GetMessageTextFragment() const {
   return l10n_util::GetStringUTF16(IDS_GEOLOCATION_INFOBAR_PERMISSION_FRAGMENT);
 }
 
 bool GeolocationPermissionRequest::HasUserGesture() const {
-  // TODO(gbillock): plumb this through from GeolocationDispatcher.
-  return false;
+  return user_gesture_;
 }
 
 GURL GeolocationPermissionRequest::GetRequestingHostname() const {
   return requesting_frame_;
 }
 
 void GeolocationPermissionRequest::PermissionGranted() {
   context_->NotifyPermissionSet(id_, requesting_frame_, callback_, true);
 }
 
@@ skipping 21 matching lines @@
   // or the IO thread, but the PermissionQueueController must have been
   // destroyed on the UI thread.
   DCHECK(!permission_queue_controller_.get());
 }
 
 void ChromeGeolocationPermissionContext::RequestGeolocationPermission(
     int render_process_id,
     int render_view_id,
     int bridge_id,
     const GURL& requesting_frame,
+    bool user_gesture,
     base::Callback<void(bool)> callback) {
   GURL requesting_frame_origin = requesting_frame.GetOrigin();
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(
             &ChromeGeolocationPermissionContext::RequestGeolocationPermission,
             this, render_process_id, render_view_id, bridge_id,
-            requesting_frame_origin, callback));
+            requesting_frame_origin, user_gesture, callback));
     return;
   }
 
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (shutting_down_)
     return;
 
   content::WebContents* web_contents =
       tab_util::GetWebContentsByID(render_process_id, render_view_id);
   const PermissionRequestID id(render_process_id, render_view_id, bridge_id, 0);
@@ skipping 29 matching lines @@
 
   GURL embedder = web_contents->GetLastCommittedURL().GetOrigin();
   if (!requesting_frame_origin.is_valid() || !embedder.is_valid()) {
     LOG(WARNING) << "Attempt to use geolocation from an invalid URL: "
                  << requesting_frame_origin << "," << embedder
                  << " (geolocation is not supported in popups)";
     NotifyPermissionSet(id, requesting_frame_origin, callback, false);
     return;
   }
 
-  DecidePermission(web_contents, id, requesting_frame_origin,
+  DecidePermission(web_contents, id, requesting_frame_origin, user_gesture,
                    embedder, "", callback);
 }
 
 void ChromeGeolocationPermissionContext::CancelGeolocationPermissionRequest(
     int render_process_id,
     int render_view_id,
     int bridge_id,
     const GURL& requesting_frame) {
   // TODO(gbillock): cancel permission bubble request.
   CancelPendingInfobarRequest(PermissionRequestID(
       render_process_id, render_view_id, bridge_id, 0));
 }
 
 void ChromeGeolocationPermissionContext::DecidePermission(
     content::WebContents* web_contents,
     const PermissionRequestID& id,
     const GURL& requesting_frame,
+    bool user_gesture,
     const GURL& embedder,
     const std::string& accept_button_label,
     base::Callback<void(bool)> callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   ContentSetting content_setting =
      profile_->GetHostContentSettingsMap()->GetContentSetting(
           requesting_frame, embedder, CONTENT_SETTINGS_TYPE_GEOLOCATION,
           std::string());
   switch (content_setting) {
     case CONTENT_SETTING_BLOCK:
       PermissionDecided(id, requesting_frame, embedder, callback, false);
       break;
     case CONTENT_SETTING_ALLOW:
       PermissionDecided(id, requesting_frame, embedder, callback, true);
       break;
     default:
       if (PermissionBubbleManager::Enabled()) {
         PermissionBubbleManager* mgr =
             PermissionBubbleManager::FromWebContents(web_contents);
         mgr->AddRequest(new GeolocationPermissionRequest(
-                this, id, requesting_frame, callback,
+                this, id, requesting_frame, user_gesture, callback,
                 profile_->GetPrefs()->GetString(prefs::kAcceptLanguages)));
       } else {
         // setting == ask. Prompt the user.
         QueueController()->CreateInfoBarRequest(
             id, requesting_frame, embedder, accept_button_label,
                 base::Bind(
                     &ChromeGeolocationPermissionContext::NotifyPermissionSet,
                 base::Unretained(this), id, requesting_frame, callback));
       }
   }
@@ skipping 71 matching lines @@
             this, id));
      return;
   }
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (shutting_down_)
     return;
 
   // TODO(gbillock): handle permission bubble cancellation.
   QueueController()->CancelInfoBarRequest(id);
 }