Location chooser

chrome/browser/geolocation/geolocation_permission_context.cc

 // Copyright 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/geolocation_permission_context.h"
 
 #include <functional>
 #include <string>
 #include <vector>
 
@@ skipping 17 matching lines @@
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 class GeolocationPermissionRequest : public PermissionBubbleRequest {
  public:
   GeolocationPermissionRequest(GeolocationPermissionContext* context,
                                const PermissionRequestID& id,
                                const GURL& requesting_frame,
                                const GURL& embedder,
                                bool user_gesture,
-                               base::Callback<void(bool)> callback,
+                               base::Callback<void(int, bool)> callback,
                                const std::string& display_languages);
   virtual ~GeolocationPermissionRequest();
 
   // PermissionBubbleDelegate:
+  virtual PermissionBubbleRequest::Type GetType() const OVERRIDE;
   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;
+  void PermissionGranted(int precision);
   virtual void PermissionDenied() OVERRIDE;
   virtual void Cancelled() OVERRIDE;
   virtual void RequestFinished() OVERRIDE;
 
  private:
   GeolocationPermissionContext* context_;
   PermissionRequestID id_;
   GURL requesting_frame_;
   GURL embedder_;
   bool user_gesture_;
-  base::Callback<void(bool)> callback_;
+  base::Callback<void(int, bool)> callback_;
   std::string display_languages_;
 };
 
 GeolocationPermissionRequest::GeolocationPermissionRequest(
     GeolocationPermissionContext* context,
     const PermissionRequestID& id,
     const GURL& requesting_frame,
     const GURL& embedder,
     bool user_gesture,
-    base::Callback<void(bool)> callback,
+    base::Callback<void(int, bool)> callback,
     const std::string& display_languages)
     : context_(context),
       id_(id),
       requesting_frame_(requesting_frame),
       embedder_(embedder),
       user_gesture_(user_gesture),
       callback_(callback),
-      display_languages_(display_languages) {}
+      display_languages_(display_languages) {
+}
 
 GeolocationPermissionRequest::~GeolocationPermissionRequest() {}
 
+PermissionBubbleRequest::Type GeolocationPermissionRequest::GetType() const {
+  return PermissionBubbleRequest::Type::kGeolocation;
+}
+
 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_.GetOrigin(), display_languages_,
                      net::kFormatUrlOmitUsernamePassword |
                      net::kFormatUrlOmitTrailingSlashOnBareHostname,
                      net::UnescapeRule::SPACES, NULL, NULL, NULL));
 }
 
 base::string16 GeolocationPermissionRequest::GetMessageTextFragment() const {
   return l10n_util::GetStringUTF16(IDS_GEOLOCATION_INFOBAR_PERMISSION_FRAGMENT);
 }
 
 bool GeolocationPermissionRequest::HasUserGesture() const {
   return user_gesture_;
 }
 
 GURL GeolocationPermissionRequest::GetRequestingHostname() const {
   return requesting_frame_;
 }
 
 void GeolocationPermissionRequest::PermissionGranted() {
+  PermissionGranted(-1);
+}
+
+void GeolocationPermissionRequest::PermissionGranted(int choice) {
+  // TODO(mohammed) Fix content setting to account for different choices.
   context_->QueueController()->UpdateContentSetting(
       requesting_frame_, embedder_, true);
-  context_->NotifyPermissionSet(id_, requesting_frame_, callback_, true);
+  context_->NotifyPermissionSet(
+      id_, requesting_frame_, callback_, true, choice);
 }
 
 void GeolocationPermissionRequest::PermissionDenied() {
   context_->QueueController()->UpdateContentSetting(
       requesting_frame_, embedder_, false);
   context_->NotifyPermissionSet(id_, requesting_frame_, callback_, false);
 }
 
 void GeolocationPermissionRequest::Cancelled() {
 }
@@ skipping 16 matching lines @@
   // or the IO thread, but the PermissionQueueController must have been
   // destroyed on the UI thread.
   DCHECK(!permission_queue_controller_.get());
 }
 
 void GeolocationPermissionContext::RequestGeolocationPermission(
     content::WebContents* web_contents,
     int bridge_id,
     const GURL& requesting_frame,
     bool user_gesture,
-    base::Callback<void(bool)> result_callback,
+    base::Callback<void(int, bool)> result_callback,
     base::Closure* cancel_callback) {
   GURL requesting_frame_origin = requesting_frame.GetOrigin();
   if (shutting_down_)
     return;
 
   int render_process_id = web_contents->GetRenderProcessHost()->GetID();
   int render_view_id = web_contents->GetRenderViewHost()->GetRoutingID();
   if (cancel_callback) {
     *cancel_callback = base::Bind(
         &GeolocationPermissionContext::CancelGeolocationPermissionRequest,
@@ skipping 40 matching lines @@
   CancelPendingInfobarRequest(PermissionRequestID(
       render_process_id, render_view_id, bridge_id, GURL()));
 }
 
 void GeolocationPermissionContext::DecidePermission(
     content::WebContents* web_contents,
     const PermissionRequestID& id,
     const GURL& requesting_frame,
     bool user_gesture,
     const GURL& embedder,
-    base::Callback<void(bool)> callback) {
+    base::Callback<void(int, bool)> callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   ContentSetting content_setting =
       profile_->GetHostContentSettingsMap()
           ->GetContentSettingAndMaybeUpdateLastUsage(
               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:
+      // We have to save the choice in the context setting to send it here.
+      // (mohammed) fix.
       PermissionDecided(id, requesting_frame, embedder, callback, true);
       break;
     default:
       if (PermissionBubbleManager::Enabled()) {
         PermissionBubbleManager* mgr =
             PermissionBubbleManager::FromWebContents(web_contents);
         if (mgr) {
           scoped_ptr<GeolocationPermissionRequest> request_ptr(
               new GeolocationPermissionRequest(
                   this, id, requesting_frame, embedder, user_gesture, callback,
                   profile_->GetPrefs()->GetString(prefs::kAcceptLanguages)));
           GeolocationPermissionRequest* request = request_ptr.get();
           pending_requests_.add(id.ToString(), request_ptr.Pass());
           mgr->AddRequest(request);
         }
       } else {
         // setting == ask. Prompt the user.
         QueueController()->CreateInfoBarRequest(
-            id, requesting_frame, embedder,
-                base::Bind(
-                    &GeolocationPermissionContext::NotifyPermissionSet,
-                base::Unretained(this), id, requesting_frame, callback));
+            id,
+            requesting_frame,
+            embedder,
+            base::Bind(
+                &GeolocationPermissionContext::NotifyInfoBarPermissionSet,
+                base::Unretained(this),
+                id,
+                requesting_frame,
+                base::Bind(callback, -1)));
       }
   }
 }
 
 void GeolocationPermissionContext::CreateInfoBarRequest(
     const PermissionRequestID& id,
     const GURL& requesting_frame,
     const GURL& embedder,
     base::Callback<void(bool)> callback) {
-    QueueController()->CreateInfoBarRequest(
-        id, requesting_frame, embedder, base::Bind(
-            &GeolocationPermissionContext::NotifyPermissionSet,
-            base::Unretained(this), id, requesting_frame, callback));
+  QueueController()->CreateInfoBarRequest(
+      id,
+      requesting_frame,
+      embedder,
+      base::Bind(&GeolocationPermissionContext::NotifyInfoBarPermissionSet,
+                 base::Unretained(this),
+                 id,
+                 requesting_frame,
+                 callback));
 }
 
 void GeolocationPermissionContext::RequestFinished(
     GeolocationPermissionRequest* request) {
   base::ScopedPtrHashMap<std::string,
                          GeolocationPermissionRequest>::iterator it;
   for (it = pending_requests_.begin(); it != pending_requests_.end(); ++it) {
     if (it->second == request) {
       pending_requests_.take_and_erase(it);
       return;
     }
   }
 }
 
 
 void GeolocationPermissionContext::ShutdownOnUIThread() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   permission_queue_controller_.reset();
   shutting_down_ = true;
 }
 
 void GeolocationPermissionContext::PermissionDecided(
     const PermissionRequestID& id,
     const GURL& requesting_frame,
     const GURL& embedder,
-    base::Callback<void(bool)> callback,
+    base::Callback<void(int, bool)> callback,
     bool allowed) {
   NotifyPermissionSet(id, requesting_frame, callback, allowed);
 }
 
 void GeolocationPermissionContext::NotifyPermissionSet(
     const PermissionRequestID& id,
     const GURL& requesting_frame,
+    base::Callback<void(int, bool)> callback,
+    bool allowed) {
+  NotifyPermissionSet(id, requesting_frame, callback, -1, allowed);
+}
+
+void GeolocationPermissionContext::NotifyPermissionSet(
+    const PermissionRequestID& id,
+    const GURL& requesting_frame,
+    base::Callback<void(int, bool)> callback,
+    bool allowed,
+    int choice) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  // WebContents may have gone away (or not exists for extension).
+  TabSpecificContentSettings* content_settings =
+      TabSpecificContentSettings::Get(id.render_process_id(),
+                                      id.render_view_id());
+  if (content_settings) {
+    // TODO(mohamed) the geolocation precision need to be passed to content

[meacer, 2014/08/15 23:34:46]

mohamed -> mohammed :) (or the engineer who'll take ownership as felt said)

+    // settings.
+    content_settings->OnGeolocationPermissionSet(requesting_frame.GetOrigin(),
+                                                 allowed);
+  }
+
+  callback.Run(allowed, choice);

[meacer, 2014/08/15 23:34:46]

This doesn't look right. The callback takes (int, bool) but you are passing
(allowed, choice)?

It would be better to make all callbacks Callback<void(bool,int)> and then pass
allowed, choice in that order, everywhere.

+}
+
+void GeolocationPermissionContext::NotifyInfoBarPermissionSet(
+    const PermissionRequestID& id,
+    const GURL& requesting_frame,
     base::Callback<void(bool)> callback,
     bool allowed) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // WebContents may have gone away (or not exists for extension).
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::Get(id.render_process_id(),
                                       id.render_view_id());
   if (content_settings) {
     content_settings->OnGeolocationPermissionSet(requesting_frame.GetOrigin(),
@@ skipping 33 matching lines @@
     if (cancelling != NULL && web_contents != NULL &&
         PermissionBubbleManager::FromWebContents(web_contents) != NULL) {
       PermissionBubbleManager::FromWebContents(web_contents)->
           CancelRequest(cancelling);
     }
     return;
   }
 
   QueueController()->CancelInfoBarRequest(id);
 }