src/chrome/browser/guest_view/web_view/chrome_web_view_permission_helper_delegate.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/guest_view/web_view/chrome_web_view_permission_helper_delegate.h"
   6
   7 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
   8 #include "chrome/browser/geolocation/geolocation_permission_context.h"
   9 #include "chrome/browser/geolocation/geolocation_permission_context_factory.h"
  10 #include "chrome/browser/guest_view/web_view/web_view_constants.h"
  11 #include "chrome/browser/guest_view/web_view/web_view_guest.h"
  12 #include "chrome/browser/plugins/chrome_plugin_service_filter.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/common/render_messages.h"
  15 #include "content/public/browser/user_metrics.h"
  16
  17 ChromeWebViewPermissionHelperDelegate::ChromeWebViewPermissionHelperDelegate(
  18     extensions::WebViewPermissionHelper* web_view_permission_helper)
  19     : WebViewPermissionHelperDelegate(
  20         web_view_permission_helper->web_view_guest()->guest_web_contents()),
  21       web_view_permission_helper_(web_view_permission_helper),
  22       weak_factory_(this) {
  23 }
  24
  25 ChromeWebViewPermissionHelperDelegate::~ChromeWebViewPermissionHelperDelegate()
  26 {}
  27
  28 #if defined(ENABLE_PLUGINS)
  29 bool ChromeWebViewPermissionHelperDelegate::OnMessageReceived(
  30     const IPC::Message& message,
  31     content::RenderFrameHost* render_frame_host) {
  32   IPC_BEGIN_MESSAGE_MAP(ChromeWebViewPermissionHelperDelegate, message)
  33     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_BlockedOutdatedPlugin,
  34                         OnBlockedOutdatedPlugin)
  35     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_BlockedUnauthorizedPlugin,
  36                         OnBlockedUnauthorizedPlugin)
  37     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_NPAPINotSupported,
  38                         OnNPAPINotSupported)
  39 #if defined(ENABLE_PLUGIN_INSTALLATION)
  40     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_FindMissingPlugin,
  41                         OnFindMissingPlugin)
  42 #endif
  43     IPC_MESSAGE_UNHANDLED(return false)
  44   IPC_END_MESSAGE_MAP()
  45
  46   return true;
  47 }
  48
  49 bool ChromeWebViewPermissionHelperDelegate::OnMessageReceived(
  50     const IPC::Message& message) {
  51   IPC_BEGIN_MESSAGE_MAP(ChromeWebViewPermissionHelperDelegate, message)
  52     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_CouldNotLoadPlugin,
  53                         OnCouldNotLoadPlugin)
  54     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_OpenAboutPlugins,
  55                         OnOpenAboutPlugins)
  56 #if defined(ENABLE_PLUGIN_INSTALLATION)
  57     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_RemovePluginPlaceholderHost,
  58                         OnRemovePluginPlaceholderHost)
  59 #endif
  60     IPC_MESSAGE_UNHANDLED(return false)
  61   IPC_END_MESSAGE_MAP()
  62
  63   return true;
  64 }
  65
  66 void ChromeWebViewPermissionHelperDelegate::OnBlockedUnauthorizedPlugin(
  67     const base::string16& name,
  68     const std::string& identifier) {
  69   const char kPluginName[] = "name";
  70   const char kPluginIdentifier[] = "identifier";
  71
  72   base::DictionaryValue info;
  73   info.SetString(std::string(kPluginName), name);
  74   info.SetString(std::string(kPluginIdentifier), identifier);
  75   web_view_permission_helper_->RequestPermission(
  76       WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN,
  77       info,
  78       base::Bind(&ChromeWebViewPermissionHelperDelegate::OnPermissionResponse,
  79                  weak_factory_.GetWeakPtr(),
  80                  identifier),
  81       true /* allowed_by_default */);
  82   content::RecordAction(
  83       base::UserMetricsAction("WebView.Guest.PluginLoadRequest"));
  84 }
  85
  86 void ChromeWebViewPermissionHelperDelegate::OnCouldNotLoadPlugin(
  87     const base::FilePath& plugin_path) {
  88 }
  89
  90 void ChromeWebViewPermissionHelperDelegate::OnBlockedOutdatedPlugin(
  91     int placeholder_id,
  92     const std::string& identifier) {
  93 }
  94
  95 void ChromeWebViewPermissionHelperDelegate::OnNPAPINotSupported(
  96     const std::string& id) {
  97 }
  98
  99 void ChromeWebViewPermissionHelperDelegate::OnOpenAboutPlugins() {
 100 }
 101
 102 #if defined(ENABLE_PLUGIN_INSTALLATION)
 103 void ChromeWebViewPermissionHelperDelegate::OnFindMissingPlugin(
 104     int placeholder_id,
 105     const std::string& mime_type) {
 106   Send(new ChromeViewMsg_DidNotFindMissingPlugin(placeholder_id));
 107 }
 108
 109 void ChromeWebViewPermissionHelperDelegate::OnRemovePluginPlaceholderHost(
 110     int placeholder_id) {
 111 }
 112 #endif  // defined(ENABLE_PLUGIN_INSTALLATION)
 113
 114 void ChromeWebViewPermissionHelperDelegate::OnPermissionResponse(
 115     const std::string& identifier,
 116     bool allow,
 117     const std::string& input) {
 118   if (allow) {
 119     ChromePluginServiceFilter::GetInstance()->AuthorizeAllPlugins(
 120         web_contents(), true, identifier);
 121   }
 122 }
 123
 124 #endif  // defined(ENABLE_PLUGINS)
 125
 126 void ChromeWebViewPermissionHelperDelegate::RequestMediaAccessPermission(
 127     content::WebContents* source,
 128     const content::MediaStreamRequest& request,
 129     const content::MediaResponseCallback& callback) {
 130   base::DictionaryValue request_info;
 131   request_info.SetString(guestview::kUrl, request.security_origin.spec());
 132   web_view_permission_helper_->RequestPermission(
 133       WEB_VIEW_PERMISSION_TYPE_MEDIA,
 134       request_info,
 135       base::Bind(
 136           &ChromeWebViewPermissionHelperDelegate::OnMediaPermissionResponse,
 137           base::Unretained(this),
 138           request,
 139           callback),
 140       false /* allowed_by_default */);
 141 }
 142
 143  void ChromeWebViewPermissionHelperDelegate::OnMediaPermissionResponse(
 144     const content::MediaStreamRequest& request,
 145     const content::MediaResponseCallback& callback,
 146     bool allow,
 147     const std::string& user_input) {
 148   if (!allow || !web_view_guest()->attached()) {
 149     // Deny the request.
 150     callback.Run(content::MediaStreamDevices(),
 151                  content::MEDIA_DEVICE_INVALID_STATE,
 152                  scoped_ptr<content::MediaStreamUI>());
 153     return;
 154   }
 155   if (!web_view_guest()->embedder_web_contents()->GetDelegate())
 156     return;
 157
 158   web_view_guest()->embedder_web_contents()->GetDelegate()->
 159       RequestMediaAccessPermission(web_view_guest()->embedder_web_contents(),
 160                                    request,
 161                                    callback);
 162 }
 163
 164 void ChromeWebViewPermissionHelperDelegate::CanDownload(
 165     content::RenderViewHost* render_view_host,
 166     const GURL& url,
 167     const std::string& request_method,
 168     const base::Callback<void(bool)>& callback) {
 169   base::DictionaryValue request_info;
 170   request_info.SetString(guestview::kUrl, url.spec());
 171   web_view_permission_helper_->RequestPermission(
 172       WEB_VIEW_PERMISSION_TYPE_DOWNLOAD,
 173       request_info,
 174       base::Bind(
 175           &ChromeWebViewPermissionHelperDelegate::OnDownloadPermissionResponse,
 176           base::Unretained(this),
 177           callback),
 178       false /* allowed_by_default */);
 179 }
 180
 181 void ChromeWebViewPermissionHelperDelegate::OnDownloadPermissionResponse(
 182     const base::Callback<void(bool)>& callback,
 183     bool allow,
 184     const std::string& user_input) {
 185   callback.Run(allow && web_view_guest()->attached());
 186 }
 187
 188 void ChromeWebViewPermissionHelperDelegate::RequestPointerLockPermission(
 189     bool user_gesture,
 190     bool last_unlocked_by_target,
 191     const base::Callback<void(bool)>& callback) {
 192   base::DictionaryValue request_info;
 193   request_info.SetBoolean(guestview::kUserGesture, user_gesture);
 194   request_info.SetBoolean(webview::kLastUnlockedBySelf,
 195                           last_unlocked_by_target);
 196   request_info.SetString(guestview::kUrl,
 197                          web_contents()->GetLastCommittedURL().spec());
 198
 199   web_view_permission_helper_->RequestPermission(
 200       WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK,
 201       request_info,
 202       base::Bind(&ChromeWebViewPermissionHelperDelegate::
 203                      OnPointerLockPermissionResponse,
 204                  base::Unretained(this),
 205                  callback),
 206       false /* allowed_by_default */);
 207 }
 208
 209 void ChromeWebViewPermissionHelperDelegate::OnPointerLockPermissionResponse(
 210     const base::Callback<void(bool)>& callback,
 211     bool allow,
 212     const std::string& user_input) {
 213   callback.Run(allow && web_view_guest()->attached());
 214 }
 215
 216 void ChromeWebViewPermissionHelperDelegate::RequestGeolocationPermission(
 217     int bridge_id,
 218     const GURL& requesting_frame,
 219     bool user_gesture,
 220     const base::Callback<void(bool)>& callback) {
 221   base::DictionaryValue request_info;
 222   request_info.SetString(guestview::kUrl, requesting_frame.spec());
 223   request_info.SetBoolean(guestview::kUserGesture, user_gesture);
 224
 225   // It is safe to hold an unretained pointer to
 226   // ChromeWebViewPermissionHelperDelegate because this callback is called from
 227   // ChromeWebViewPermissionHelperDelegate::SetPermission.
 228   const extensions::WebViewPermissionHelper::PermissionResponseCallback
 229       permission_callback =
 230       base::Bind(&ChromeWebViewPermissionHelperDelegate::
 231                      OnGeolocationPermissionResponse,
 232                  base::Unretained(this),
 233                  bridge_id,
 234                  user_gesture,
 235                  callback);
 236   int request_id = web_view_permission_helper_->RequestPermission(
 237       WEB_VIEW_PERMISSION_TYPE_GEOLOCATION,
 238       request_info,
 239       permission_callback,
 240       false /* allowed_by_default */);
 241   bridge_id_to_request_id_map_[bridge_id] = request_id;
 242 }
 243
 244 void ChromeWebViewPermissionHelperDelegate::OnGeolocationPermissionResponse(
 245     int bridge_id,
 246     bool user_gesture,
 247     const base::Callback<void(bool)>& callback,
 248     bool allow,
 249     const std::string& user_input) {
 250   // The <webview> embedder has allowed the permission. We now need to make sure
 251   // that the embedder has geolocation permission.
 252   RemoveBridgeID(bridge_id);
 253
 254   if (!allow || !web_view_guest()->attached()) {
 255     callback.Run(false);
 256     return;
 257   }
 258
 259   Profile* profile = Profile::FromBrowserContext(
 260       web_view_guest()->browser_context());
 261   GeolocationPermissionContextFactory::GetForProfile(profile)->
 262       RequestGeolocationPermission(
 263           web_view_guest()->embedder_web_contents(),
 264           // The geolocation permission request here is not initiated
 265           // through WebGeolocationPermissionRequest. We are only interested
 266           // in the fact whether the embedder/app has geolocation
 267           // permission. Therefore we use an invalid |bridge_id|.
 268           -1,
 269           web_view_guest()->embedder_web_contents()->GetLastCommittedURL(),
 270           user_gesture,
 271           callback,
 272           NULL);
 273 }
 274
 275 void ChromeWebViewPermissionHelperDelegate::CancelGeolocationPermissionRequest(
 276     int bridge_id) {
 277   int request_id = RemoveBridgeID(bridge_id);
 278   web_view_permission_helper_->CancelPendingPermissionRequest(request_id);
 279 }
 280
 281 int ChromeWebViewPermissionHelperDelegate::RemoveBridgeID(int bridge_id) {
 282   std::map<int, int>::iterator bridge_itr =
 283       bridge_id_to_request_id_map_.find(bridge_id);
 284   if (bridge_itr == bridge_id_to_request_id_map_.end())
 285     return webview::kInvalidPermissionRequestID;
 286
 287   int request_id = bridge_itr->second;
 288   bridge_id_to_request_id_map_.erase(bridge_itr);
 289   return request_id;
 290 }
 291
 292 void ChromeWebViewPermissionHelperDelegate::RequestFileSystemPermission(
 293     const GURL& url,
 294     bool allowed_by_default,
 295     const base::Callback<void(bool)>& callback) {
 296   base::DictionaryValue request_info;
 297   request_info.SetString(guestview::kUrl, url.spec());
 298   web_view_permission_helper_->RequestPermission(
 299       WEB_VIEW_PERMISSION_TYPE_FILESYSTEM,
 300       request_info,
 301       base::Bind(&ChromeWebViewPermissionHelperDelegate::
 302                      OnFileSystemPermissionResponse,
 303                  base::Unretained(this),
 304                  callback),
 305       allowed_by_default);
 306 }
 307
 308 void ChromeWebViewPermissionHelperDelegate::OnFileSystemPermissionResponse(
 309     const base::Callback<void(bool)>& callback,
 310     bool allow,
 311     const std::string& user_input) {
 312   callback.Run(allow && web_view_guest()->attached());
 313 }
 314
 315 void ChromeWebViewPermissionHelperDelegate::FileSystemAccessedAsync(
 316     int render_process_id,
 317     int render_frame_id,
 318     int request_id,
 319     const GURL& url,
 320     bool blocked_by_policy) {
 321   RequestFileSystemPermission(
 322       url,
 323       !blocked_by_policy,
 324       base::Bind(&ChromeWebViewPermissionHelperDelegate::
 325                      FileSystemAccessedAsyncResponse,
 326                  base::Unretained(this),
 327                  render_process_id,
 328                  render_frame_id,
 329                  request_id,
 330                  url));
 331 }
 332
 333 void ChromeWebViewPermissionHelperDelegate::FileSystemAccessedAsyncResponse(
 334     int render_process_id,
 335     int render_frame_id,
 336     int request_id,
 337     const GURL& url,
 338     bool allowed) {
 339   TabSpecificContentSettings::FileSystemAccessed(
 340       render_process_id, render_frame_id, url, !allowed);
 341   Send(new ChromeViewMsg_RequestFileSystemAccessAsyncResponse(
 342       render_frame_id, request_id, allowed));
 343 }
 344
 345 void ChromeWebViewPermissionHelperDelegate::FileSystemAccessedSync(
 346     int render_process_id,
 347     int render_frame_id,
 348     const GURL& url,
 349     bool blocked_by_policy,
 350     IPC::Message* reply_msg) {
 351   RequestFileSystemPermission(
 352       url,
 353       !blocked_by_policy,
 354       base::Bind(&ChromeWebViewPermissionHelperDelegate::
 355                      FileSystemAccessedSyncResponse,
 356                  base::Unretained(this),
 357                  render_process_id,
 358                  render_frame_id,
 359                  url,
 360                  reply_msg));
 361 }
 362
 363 void ChromeWebViewPermissionHelperDelegate::FileSystemAccessedSyncResponse(
 364     int render_process_id,
 365     int render_frame_id,
 366     const GURL& url,
 367     IPC::Message* reply_msg,
 368     bool allowed) {
 369   TabSpecificContentSettings::FileSystemAccessed(
 370       render_process_id, render_frame_id, url, !allowed);
 371   ChromeViewHostMsg_RequestFileSystemAccessSync::WriteReplyParams(reply_msg,
 372                                                                   allowed);
 373   Send(reply_msg);
 374 }