[Geolocation] Add permission bubble client.

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>
 
 #include "base/bind.h"
+#include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/content_settings/permission_request_id.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/extensions/suggest_permission_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_delegate.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
+#include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_map.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/extension.h"
+#include "grit/generated_resources.h"
+#include "net/base/net_util.h"
+#include "ui/base/l10n/l10n_util.h"
 
 using extensions::APIPermission;
 using extensions::ExtensionRegistry;
 
+class GeolocationPermissionBubbleDelegate : public PermissionBubbleDelegate {
+ public:
+  GeolocationPermissionBubbleDelegate(
+    ChromeGeolocationPermissionContext* context,

[timvolodine, 2014/02/05 12:26:15]

indent 4 spaces

[Greg Billock, 2014/02/05 16:46:38]

Done.

+    const PermissionRequestID& id,
+    const GURL& requesting_frame,
+    base::Callback<void(bool)> callback,
+    const std::string& display_languages);
+  virtual ~GeolocationPermissionBubbleDelegate();
+
+  // PermissionBubbleDelegate:
+  virtual base::string16 GetMessageText() const OVERRIDE;
+  virtual base::string16 GetMessageTextFragment() const OVERRIDE;
+  virtual base::string16 GetAlternateAcceptButtonText() const OVERRIDE;
+  virtual base::string16 GetAlternateDenyButtonText() 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_;
+  base::Callback<void(bool)> callback_;
+  std::string display_languages_;
+};
+
+GeolocationPermissionBubbleDelegate::GeolocationPermissionBubbleDelegate(
+    ChromeGeolocationPermissionContext* context,
+    const PermissionRequestID& id,
+    const GURL& requesting_frame,
+    base::Callback<void(bool)> callback,
+    const std::string& display_languages)
+    : context_(context),
+      id_(id),
+      requesting_frame_(requesting_frame),
+      callback_(callback),
+      display_languages_(display_languages) {}
+
+GeolocationPermissionBubbleDelegate::~GeolocationPermissionBubbleDelegate() {}
+
+base::string16 GeolocationPermissionBubbleDelegate::GetMessageText() const {
+  return l10n_util::GetStringFUTF16(IDS_GEOLOCATION_INFOBAR_QUESTION,
+      net::FormatUrl(requesting_frame_, display_languages_));
+}
+
+base::string16
+GeolocationPermissionBubbleDelegate::GetMessageTextFragment() const {
+  return l10n_util::GetStringUTF16(IDS_GEOLOCATION_INFOBAR_PERMISSION_FRAGMENT);
+}
+
+base::string16
+GeolocationPermissionBubbleDelegate::GetAlternateAcceptButtonText() const {
+  return l10n_util::GetStringUTF16(IDS_GEOLOCATION_ALLOW_BUTTON);
+}
+
+base::string16
+GeolocationPermissionBubbleDelegate::GetAlternateDenyButtonText() const {
+  return l10n_util::GetStringUTF16(IDS_GEOLOCATION_DENY_BUTTON);
+}
+
+void GeolocationPermissionBubbleDelegate::PermissionGranted() {
+  context_->NotifyPermissionSet(id_, requesting_frame_, callback_, true);
+}
+
+void GeolocationPermissionBubbleDelegate::PermissionDenied() {
+  context_->NotifyPermissionSet(id_, requesting_frame_, callback_, false);
+}
+
+void GeolocationPermissionBubbleDelegate::Cancelled() {
+  context_->NotifyPermissionSet(id_, requesting_frame_, callback_, false);
+}
+
+void GeolocationPermissionBubbleDelegate::RequestFinished() {
+  delete this;
+}
+
+
 ChromeGeolocationPermissionContext::ChromeGeolocationPermissionContext(
     Profile* profile)
     : profile_(profile),
       shutting_down_(false) {
 }
 
 ChromeGeolocationPermissionContext::~ChromeGeolocationPermissionContext() {
   // ChromeGeolocationPermissionContext may be destroyed on either the UI thread
   // or the IO thread, but the PermissionQueueController must have been
   // destroyed on the UI thread.
@@ skipping 56 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(id, requesting_frame_origin, embedder, callback);
+  DecidePermission(web_contents, id, requesting_frame_origin,
+                   embedder, callback);
 }
 
 void ChromeGeolocationPermissionContext::CancelGeolocationPermissionRequest(
     int render_process_id,
     int render_view_id,
     int bridge_id,
     const GURL& requesting_frame) {
   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,
     const GURL& embedder,
     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:
-      // setting == ask. Prompt the user.
-      QueueController()->CreateInfoBarRequest(
-          id, requesting_frame, embedder, base::Bind(
-              &ChromeGeolocationPermissionContext::NotifyPermissionSet,
-              base::Unretained(this), id, requesting_frame, callback));
+      if (PermissionBubbleManager::Enabled()) {
+        PermissionBubbleManager* mgr =
+            PermissionBubbleManager::FromWebContents(web_contents);
+        mgr->AddPermissionBubbleDelegate(
+            new GeolocationPermissionBubbleDelegate(
+                this, id, requesting_frame, callback,
+                profile_->GetPrefs()->GetString(prefs::kAcceptLanguages)));
+      } else {
+        // setting == ask. Prompt the user.
+        QueueController()->CreateInfoBarRequest(
+            id, requesting_frame, embedder, base::Bind(
+                &ChromeGeolocationPermissionContext::NotifyPermissionSet,
+                base::Unretained(this), id, requesting_frame, callback));
+      }
   }
 }
 
 void ChromeGeolocationPermissionContext::ShutdownOnUIThread() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   permission_queue_controller_.reset();
   shutting_down_ = true;
 }
 
 void ChromeGeolocationPermissionContext::PermissionDecided(
@@ skipping 48 matching lines @@
         base::Bind(
             &ChromeGeolocationPermissionContext::CancelPendingInfobarRequest,
             this, id));
      return;
   }
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (shutting_down_)
     return;
   QueueController()->CancelInfoBarRequest(id);
 }