<webview>: Move Geolocation permission to chrome layer.

chrome/browser/guestview/webview/webview_guest.cc

 // Copyright 2013 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/guestview/webview/webview_guest.h"
 
+#include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/extensions/api/webview/webview_api.h"
 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
 #include "chrome/browser/extensions/extension_renderer_state.h"
 #include "chrome/browser/extensions/menu_manager.h"
 #include "chrome/browser/extensions/script_executor.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/guestview/guestview_constants.h"
 #include "chrome/browser/guestview/webview/webview_constants.h"
 #include "chrome/browser/guestview/webview/webview_permission_types.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/geolocation_permission_context.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/storage_partition.h"
@@ skipping 37 matching lines @@
       break;
   }
   NOTREACHED() << "Unknown Termination Status.";
   return "unknown";
 }
 
 static std::string PermissionTypeToString(BrowserPluginPermissionType type) {
   switch (type) {
     case BROWSER_PLUGIN_PERMISSION_TYPE_DOWNLOAD:
       return webview::kPermissionTypeDownload;
-    case BROWSER_PLUGIN_PERMISSION_TYPE_GEOLOCATION:
-      return webview::kPermissionTypeGeolocation;
     case BROWSER_PLUGIN_PERMISSION_TYPE_MEDIA:
       return webview::kPermissionTypeMedia;
     case BROWSER_PLUGIN_PERMISSION_TYPE_NEW_WINDOW:
       return webview::kPermissionTypeNewWindow;
     case BROWSER_PLUGIN_PERMISSION_TYPE_POINTER_LOCK:
       return webview::kPermissionTypePointerLock;
     case BROWSER_PLUGIN_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
       return webview::kPermissionTypeDialog;
     case BROWSER_PLUGIN_PERMISSION_TYPE_UNKNOWN:
       NOTREACHED();
       break;
     default: {
       WebViewPermissionType webview = static_cast<WebViewPermissionType>(type);
       switch (webview) {
         case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
           return webview::kPermissionTypeLoadPlugin;
+        case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION:
+          return webview::kPermissionTypeGeolocation;
       }
       NOTREACHED();
     }
   }
   return std::string();
 }
 
 void RemoveWebViewEventListenersOnIOThread(
     void* profile,
     const std::string& extension_id,
@@ skipping 80 matching lines @@
   if (allow) {
     // Note that |allow| == true means the embedder explicitly allowed the
     // request. For some requests they might still fail. An example of such
     // scenario would be: an embedder allows geolocation request but doesn't
     // have geolocation access on its own.
     switch (info.permission_type) {
       case BROWSER_PLUGIN_PERMISSION_TYPE_DOWNLOAD:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionAllow.Download"));
         break;
-      case BROWSER_PLUGIN_PERMISSION_TYPE_GEOLOCATION:
-        content::RecordAction(
-            UserMetricsAction("BrowserPlugin.PermissionAllow.Geolocation"));
-        break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_MEDIA:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionAllow.Media"));
         break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_POINTER_LOCK:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionAllow.PointerLock"));
         break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_NEW_WINDOW:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionAllow.NewWindow"));
         break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionAllow.JSDialog"));
         break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_UNKNOWN:
         break;
       default: {
         WebViewPermissionType webview_permission_type =
             static_cast<WebViewPermissionType>(info.permission_type);
         switch (webview_permission_type) {
           case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
             content::RecordAction(
                 UserMetricsAction("WebView.Guest.PermissionAllow.PluginLoad"));
             break;
+          case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION:
+            content::RecordAction(
+                UserMetricsAction("WebView.PermissionAllow.Geolocation"));
+            break;
           default:
             break;
         }
       }
     }
   } else {
     switch (info.permission_type) {
       case BROWSER_PLUGIN_PERMISSION_TYPE_DOWNLOAD:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionDeny.Download"));
         break;
-      case BROWSER_PLUGIN_PERMISSION_TYPE_GEOLOCATION:
-        content::RecordAction(
-            UserMetricsAction("BrowserPlugin.PermissionDeny.Geolocation"));
-        break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_MEDIA:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionDeny.Media"));
         break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_POINTER_LOCK:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionDeny.PointerLock"));
         break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_NEW_WINDOW:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionDeny.NewWindow"));
         break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
         content::RecordAction(
             UserMetricsAction("BrowserPlugin.PermissionDeny.JSDialog"));
         break;
       case BROWSER_PLUGIN_PERMISSION_TYPE_UNKNOWN:
         break;
       default: {
         WebViewPermissionType webview_permission_type =
             static_cast<WebViewPermissionType>(info.permission_type);
         switch (webview_permission_type) {
           case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
             content::RecordAction(
                 UserMetricsAction("WebView.Guest.PermissionDeny.PluginLoad"));
             break;
+          case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION:
+            content::RecordAction(
+                UserMetricsAction("WebView.PermissionDeny.Geolocation"));
+            break;
           default:
             break;
         }
       }
     }
   }
 }
 
 void WebViewGuest::Attach(WebContents* embedder_web_contents,
                           const base::DictionaryValue& args) {
@@ skipping 153 matching lines @@
   DispatchEvent(new GuestView::Event(webview::kEventResponsive, args.Pass()));
 }
 
 void WebViewGuest::RendererUnresponsive() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
   DispatchEvent(new GuestView::Event(webview::kEventUnresponsive, args.Pass()));
 }
 
-bool WebViewGuest::RequestPermission(
+int WebViewGuest::RequestPermission(
     BrowserPluginPermissionType permission_type,
     const base::DictionaryValue& request_info,
     const PermissionResponseCallback& callback,
     bool allowed_by_default) {
   // If there are too many pending permission requests then reject this request.
   if (pending_permission_requests_.size() >=
       webview::kMaxOutstandingPermissionRequests) {
-    callback.Run(false, std::string());
-    return true;
+    // Let the stack unwind before we deny the permission request so that
+    // objects held by the permission request are not destroyed immediately
+    // after creation. This is to allow those same objects to be accessed again
+    // in the same scope without fear of use after freeing.
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&PermissionResponseCallback::Run,
+                  base::Owned(new PermissionResponseCallback(callback)),
+                  allowed_by_default,
+                  std::string()));
+    return webview::kInvalidPermissionRequestID;
   }
 
   int request_id = next_permission_request_id_++;
   pending_permission_requests_[request_id] =
       PermissionResponseInfo(callback, permission_type, allowed_by_default);
   scoped_ptr<base::DictionaryValue> args(request_info.DeepCopy());
   args->SetInteger(webview::kRequestId, request_id);
   switch (permission_type) {
     case BROWSER_PLUGIN_PERMISSION_TYPE_NEW_WINDOW: {
       DispatchEvent(new GuestView::Event(webview::kEventNewWindow,
                                          args.Pass()));
       break;
     }
     case BROWSER_PLUGIN_PERMISSION_TYPE_JAVASCRIPT_DIALOG: {
       DispatchEvent(new GuestView::Event(webview::kEventDialog,
                                          args.Pass()));
       break;
     }
     default: {
       args->SetString(webview::kPermission,
                       PermissionTypeToString(permission_type));
       DispatchEvent(new GuestView::Event(webview::kEventPermissionRequest,
                                          args.Pass()));
       break;
     }
   }
-  return true;
+  return request_id;
 }
 
 void WebViewGuest::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME: {
       DCHECK_EQ(content::Source<WebContents>(source).ptr(),
                 guest_web_contents());
       if (content::Source<WebContents>(source).ptr() == guest_web_contents())
@@ skipping 50 matching lines @@
   guest_web_contents()->GetController().GoToOffset(relative_index);
 }
 
 void WebViewGuest::Reload() {
   // TODO(fsamuel): Don't check for repost because we don't want to show
   // Chromium's repost warning. We might want to implement a separate API
   // for registering a callback if a repost is about to happen.
   guest_web_contents()->GetController().Reload(false);
 }
 
+
+void WebViewGuest::RequestGeolocationPermission(
+    int bridge_id,
+    const GURL& requesting_frame,
+    bool user_gesture,
+    const base::Callback<void(bool)>& callback) {
+  base::DictionaryValue request_info;
+  request_info.Set(guestview::kUrl,
+                   base::Value::CreateStringValue(requesting_frame.spec()));
+  request_info.Set(guestview::kUserGesture,
+                   base::Value::CreateBooleanValue(user_gesture));
+  int request_id = RequestPermission(
+      static_cast<BrowserPluginPermissionType>(
+          WEB_VIEW_PERMISSION_TYPE_GEOLOCATION),
+      request_info,
+      base::Bind(&WebViewGuest::OnWebViewGeolocationPermissionResponse,
+                 base::Unretained(this),
+                 bridge_id,
+                 user_gesture,
+                 callback),
+      false /* allowed_by_default */);
+  bridge_id_to_request_id_map_[bridge_id] = request_id;
+}
+
+void WebViewGuest::OnWebViewGeolocationPermissionResponse(
+    int bridge_id,
+    bool user_gesture,
+    const base::Callback<void(bool)>& callback,
+    bool allow,
+    const std::string& user_input) {
+  // The <webview> embedder has allowed the permission. We now need to make sure
+  // that the embedder has geolocation permission.
+  RemoveBridgeID(bridge_id);
+
+  if (!allow || !attached()) {
+    callback.Run(false);
+    return;
+  }
+
+  content::GeolocationPermissionContext* geolocation_context =
+      browser_context()->GetGeolocationPermissionContext();
+
+  DCHECK(geolocation_context);
+  geolocation_context->RequestGeolocationPermission(
+      embedder_web_contents()->GetRenderProcessHost()->GetID(),
+      embedder_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 */,
+      embedder_web_contents()->GetLastCommittedURL(),
+      user_gesture,
+      callback);
+}
+
+void WebViewGuest::CancelGeolocationPermissionRequest(int bridge_id) {
+  int request_id = RemoveBridgeID(bridge_id);
+  RequestMap::iterator request_itr =
+      pending_permission_requests_.find(request_id);
+
+  if (request_itr == pending_permission_requests_.end())
+    return;
+
+  pending_permission_requests_.erase(request_itr);
+}
+
 WebViewGuest::SetPermissionResult WebViewGuest::SetPermission(
     int request_id,
     PermissionResponseAction action,
     const std::string& user_input) {
   RequestMap::iterator request_itr =
       pending_permission_requests_.find(request_id);
 
   if (request_itr == pending_permission_requests_.end())
     return SET_PERMISSION_INVALID;
 
@@ skipping 254 matching lines @@
     chromeos::AccessibilityManager* manager =
         chromeos::AccessibilityManager::Get();
     if (manager && manager->IsSpokenFeedbackEnabled()) {
       manager->InjectChromeVox(render_view_host);
       chromevox_injected_ = true;
     }
   }
 #endif
 }
 
+int WebViewGuest::RemoveBridgeID(int bridge_id) {
+  std::map<int, int>::iterator bridge_itr =
+      bridge_id_to_request_id_map_.find(bridge_id);
+  if (bridge_itr == bridge_id_to_request_id_map_.end())
+    return webview::kInvalidPermissionRequestID;
+
+  int request_id = bridge_itr->second;
+  bridge_id_to_request_id_map_.erase(bridge_itr);
+  return request_id;
+}
+
+
 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo()
     : permission_type(BROWSER_PLUGIN_PERMISSION_TYPE_UNKNOWN),
       allowed_by_default(false) {
 }
 
 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo(
     const PermissionResponseCallback& callback,
     BrowserPluginPermissionType permission_type,
     bool allowed_by_default)
     : callback(callback),
       permission_type(permission_type),
       allowed_by_default(allowed_by_default) {
 }
 
 WebViewGuest::PermissionResponseInfo::~PermissionResponseInfo() {
 }