| OLD | NEW |
|---|
| (Empty) |
| 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 "extensions/browser/guest_view/web_view/web_view_permission_helper.h" | |
| 6 | |
| 7 #include "content/public/browser/render_process_host.h" | |
| 8 #include "content/public/browser/render_view_host.h" | |
| 9 #include "content/public/browser/user_metrics.h" | |
| 10 #include "extensions/browser/api/extensions_api_client.h" | |
| 11 #include "extensions/browser/guest_view/web_view/web_view_constants.h" | |
| 12 #include "extensions/browser/guest_view/web_view/web_view_guest.h" | |
| 13 #include "extensions/browser/guest_view/web_view/web_view_permission_helper_dele
gate.h" | |
| 14 #include "extensions/browser/guest_view/web_view/web_view_permission_types.h" | |
| 15 | |
| 16 using content::BrowserPluginGuestDelegate; | |
| 17 using content::RenderViewHost; | |
| 18 | |
| 19 namespace extensions { | |
| 20 | |
| 21 namespace { | |
| 22 static std::string PermissionTypeToString(WebViewPermissionType type) { | |
| 23 switch (type) { | |
| 24 case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD: | |
| 25 return webview::kPermissionTypeDownload; | |
| 26 case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM: | |
| 27 return webview::kPermissionTypeFileSystem; | |
| 28 case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION: | |
| 29 return webview::kPermissionTypeGeolocation; | |
| 30 case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: | |
| 31 return webview::kPermissionTypeDialog; | |
| 32 case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN: | |
| 33 return webview::kPermissionTypeLoadPlugin; | |
| 34 case WEB_VIEW_PERMISSION_TYPE_MEDIA: | |
| 35 return webview::kPermissionTypeMedia; | |
| 36 case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: | |
| 37 return webview::kPermissionTypeNewWindow; | |
| 38 case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK: | |
| 39 return webview::kPermissionTypePointerLock; | |
| 40 default: | |
| 41 NOTREACHED(); | |
| 42 return std::string(); | |
| 43 } | |
| 44 } | |
| 45 | |
| 46 // static | |
| 47 void RecordUserInitiatedUMA( | |
| 48 const WebViewPermissionHelper::PermissionResponseInfo& info, | |
| 49 bool allow) { | |
| 50 if (allow) { | |
| 51 // Note that |allow| == true means the embedder explicitly allowed the | |
| 52 // request. For some requests they might still fail. An example of such | |
| 53 // scenario would be: an embedder allows geolocation request but doesn't | |
| 54 // have geolocation access on its own. | |
| 55 switch (info.permission_type) { | |
| 56 case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD: | |
| 57 content::RecordAction( | |
| 58 UserMetricsAction("WebView.PermissionAllow.Download")); | |
| 59 break; | |
| 60 case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM: | |
| 61 content::RecordAction( | |
| 62 UserMetricsAction("WebView.PermissionAllow.FileSystem")); | |
| 63 break; | |
| 64 case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION: | |
| 65 content::RecordAction( | |
| 66 UserMetricsAction("WebView.PermissionAllow.Geolocation")); | |
| 67 break; | |
| 68 case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: | |
| 69 content::RecordAction( | |
| 70 UserMetricsAction("WebView.PermissionAllow.JSDialog")); | |
| 71 break; | |
| 72 case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN: | |
| 73 content::RecordAction( | |
| 74 UserMetricsAction("WebView.Guest.PermissionAllow.PluginLoad")); | |
| 75 case WEB_VIEW_PERMISSION_TYPE_MEDIA: | |
| 76 content::RecordAction( | |
| 77 UserMetricsAction("WebView.PermissionAllow.Media")); | |
| 78 break; | |
| 79 case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: | |
| 80 content::RecordAction( | |
| 81 UserMetricsAction("BrowserPlugin.PermissionAllow.NewWindow")); | |
| 82 break; | |
| 83 case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK: | |
| 84 content::RecordAction( | |
| 85 UserMetricsAction("WebView.PermissionAllow.PointerLock")); | |
| 86 break; | |
| 87 default: | |
| 88 break; | |
| 89 } | |
| 90 } else { | |
| 91 switch (info.permission_type) { | |
| 92 case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD: | |
| 93 content::RecordAction( | |
| 94 UserMetricsAction("WebView.PermissionDeny.Download")); | |
| 95 break; | |
| 96 case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM: | |
| 97 content::RecordAction( | |
| 98 UserMetricsAction("WebView.PermissionDeny.FileSystem")); | |
| 99 break; | |
| 100 case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION: | |
| 101 content::RecordAction( | |
| 102 UserMetricsAction("WebView.PermissionDeny.Geolocation")); | |
| 103 break; | |
| 104 case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: | |
| 105 content::RecordAction( | |
| 106 UserMetricsAction("WebView.PermissionDeny.JSDialog")); | |
| 107 break; | |
| 108 case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN: | |
| 109 content::RecordAction( | |
| 110 UserMetricsAction("WebView.Guest.PermissionDeny.PluginLoad")); | |
| 111 break; | |
| 112 case WEB_VIEW_PERMISSION_TYPE_MEDIA: | |
| 113 content::RecordAction( | |
| 114 UserMetricsAction("WebView.PermissionDeny.Media")); | |
| 115 break; | |
| 116 case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: | |
| 117 content::RecordAction( | |
| 118 UserMetricsAction("BrowserPlugin.PermissionDeny.NewWindow")); | |
| 119 break; | |
| 120 case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK: | |
| 121 content::RecordAction( | |
| 122 UserMetricsAction("WebView.PermissionDeny.PointerLock")); | |
| 123 break; | |
| 124 default: | |
| 125 break; | |
| 126 } | |
| 127 } | |
| 128 } | |
| 129 | |
| 130 } // namespace | |
| 131 | |
| 132 WebViewPermissionHelper::WebViewPermissionHelper(WebViewGuest* web_view_guest) | |
| 133 : content::WebContentsObserver(web_view_guest->guest_web_contents()), | |
| 134 next_permission_request_id_(guestview::kInstanceIDNone), | |
| 135 web_view_guest_(web_view_guest), | |
| 136 weak_factory_(this) { | |
| 137 web_view_permission_helper_delegate_.reset( | |
| 138 ExtensionsAPIClient::Get()->CreateWebViewPermissionHelperDelegate( | |
| 139 this)); | |
| 140 } | |
| 141 | |
| 142 WebViewPermissionHelper::~WebViewPermissionHelper() { | |
| 143 } | |
| 144 | |
| 145 // static | |
| 146 WebViewPermissionHelper* WebViewPermissionHelper::FromFrameID( | |
| 147 int render_process_id, | |
| 148 int render_frame_id) { | |
| 149 WebViewGuest* web_view_guest = WebViewGuest::FromFrameID( | |
| 150 render_process_id, render_frame_id); | |
| 151 if (!web_view_guest) { | |
| 152 return NULL; | |
| 153 } | |
| 154 return web_view_guest->web_view_permission_helper_.get(); | |
| 155 } | |
| 156 | |
| 157 // static | |
| 158 WebViewPermissionHelper* WebViewPermissionHelper::FromWebContents( | |
| 159 content::WebContents* web_contents) { | |
| 160 WebViewGuest* web_view_guest = WebViewGuest::FromWebContents(web_contents); | |
| 161 if (!web_view_guest) | |
| 162 return NULL; | |
| 163 return web_view_guest->web_view_permission_helper_.get(); | |
| 164 } | |
| 165 | |
| 166 #if defined(ENABLE_PLUGINS) | |
| 167 bool WebViewPermissionHelper::OnMessageReceived( | |
| 168 const IPC::Message& message, | |
| 169 content::RenderFrameHost* render_frame_host) { | |
| 170 return web_view_permission_helper_delegate_->OnMessageReceived( | |
| 171 message, render_frame_host); | |
| 172 } | |
| 173 | |
| 174 bool WebViewPermissionHelper::OnMessageReceived(const IPC::Message& message) { | |
| 175 return web_view_permission_helper_delegate_->OnMessageReceived(message); | |
| 176 } | |
| 177 #endif // defined(ENABLE_PLUGINS) | |
| 178 | |
| 179 void WebViewPermissionHelper::RequestMediaAccessPermission( | |
| 180 content::WebContents* source, | |
| 181 const content::MediaStreamRequest& request, | |
| 182 const content::MediaResponseCallback& callback) { | |
| 183 web_view_permission_helper_delegate_-> RequestMediaAccessPermission( | |
| 184 source, request, callback); | |
| 185 } | |
| 186 | |
| 187 void WebViewPermissionHelper::CanDownload( | |
| 188 content::RenderViewHost* render_view_host, | |
| 189 const GURL& url, | |
| 190 const std::string& request_method, | |
| 191 const base::Callback<void(bool)>& callback) { | |
| 192 web_view_permission_helper_delegate_->CanDownload( | |
| 193 render_view_host, url, request_method, callback); | |
| 194 } | |
| 195 | |
| 196 void WebViewPermissionHelper::RequestPointerLockPermission( | |
| 197 bool user_gesture, | |
| 198 bool last_unlocked_by_target, | |
| 199 const base::Callback<void(bool)>& callback) { | |
| 200 web_view_permission_helper_delegate_->RequestPointerLockPermission( | |
| 201 user_gesture, last_unlocked_by_target, callback); | |
| 202 } | |
| 203 | |
| 204 void WebViewPermissionHelper::RequestGeolocationPermission( | |
| 205 int bridge_id, | |
| 206 const GURL& requesting_frame, | |
| 207 bool user_gesture, | |
| 208 const base::Callback<void(bool)>& callback) { | |
| 209 web_view_permission_helper_delegate_->RequestGeolocationPermission( | |
| 210 bridge_id, requesting_frame, user_gesture, callback); | |
| 211 } | |
| 212 | |
| 213 void WebViewPermissionHelper::CancelGeolocationPermissionRequest( | |
| 214 int bridge_id) { | |
| 215 web_view_permission_helper_delegate_->CancelGeolocationPermissionRequest( | |
| 216 bridge_id); | |
| 217 } | |
| 218 | |
| 219 void WebViewPermissionHelper::RequestFileSystemPermission( | |
| 220 const GURL& url, | |
| 221 bool allowed_by_default, | |
| 222 const base::Callback<void(bool)>& callback) { | |
| 223 web_view_permission_helper_delegate_->RequestFileSystemPermission( | |
| 224 url, allowed_by_default, callback); | |
| 225 } | |
| 226 | |
| 227 void WebViewPermissionHelper::FileSystemAccessedAsync(int render_process_id, | |
| 228 int render_frame_id, | |
| 229 int request_id, | |
| 230 const GURL& url, | |
| 231 bool blocked_by_policy) { | |
| 232 web_view_permission_helper_delegate_->FileSystemAccessedAsync( | |
| 233 render_process_id, render_frame_id, request_id, url, blocked_by_policy); | |
| 234 } | |
| 235 | |
| 236 void WebViewPermissionHelper::FileSystemAccessedSync(int render_process_id, | |
| 237 int render_frame_id, | |
| 238 const GURL& url, | |
| 239 bool blocked_by_policy, | |
| 240 IPC::Message* reply_msg) { | |
| 241 web_view_permission_helper_delegate_->FileSystemAccessedSync( | |
| 242 render_process_id, render_frame_id, url, blocked_by_policy, reply_msg); | |
| 243 } | |
| 244 | |
| 245 int WebViewPermissionHelper::RequestPermission( | |
| 246 WebViewPermissionType permission_type, | |
| 247 const base::DictionaryValue& request_info, | |
| 248 const PermissionResponseCallback& callback, | |
| 249 bool allowed_by_default) { | |
| 250 // If there are too many pending permission requests then reject this request. | |
| 251 if (pending_permission_requests_.size() >= | |
| 252 webview::kMaxOutstandingPermissionRequests) { | |
| 253 // Let the stack unwind before we deny the permission request so that | |
| 254 // objects held by the permission request are not destroyed immediately | |
| 255 // after creation. This is to allow those same objects to be accessed again | |
| 256 // in the same scope without fear of use after freeing. | |
| 257 base::MessageLoop::current()->PostTask( | |
| 258 FROM_HERE, | |
| 259 base::Bind(&PermissionResponseCallback::Run, | |
| 260 base::Owned(new PermissionResponseCallback(callback)), | |
| 261 allowed_by_default, | |
| 262 std::string())); | |
| 263 return webview::kInvalidPermissionRequestID; | |
| 264 } | |
| 265 | |
| 266 int request_id = next_permission_request_id_++; | |
| 267 pending_permission_requests_[request_id] = | |
| 268 PermissionResponseInfo(callback, permission_type, allowed_by_default); | |
| 269 scoped_ptr<base::DictionaryValue> args(request_info.DeepCopy()); | |
| 270 args->SetInteger(webview::kRequestId, request_id); | |
| 271 switch (permission_type) { | |
| 272 case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: { | |
| 273 web_view_guest_->DispatchEventToEmbedder( | |
| 274 new GuestViewBase::Event(webview::kEventNewWindow, args.Pass())); | |
| 275 break; | |
| 276 } | |
| 277 case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: { | |
| 278 web_view_guest_->DispatchEventToEmbedder( | |
| 279 new GuestViewBase::Event(webview::kEventDialog, args.Pass())); | |
| 280 break; | |
| 281 } | |
| 282 default: { | |
| 283 args->SetString(webview::kPermission, | |
| 284 PermissionTypeToString(permission_type)); | |
| 285 web_view_guest_->DispatchEventToEmbedder(new GuestViewBase::Event( | |
| 286 webview::kEventPermissionRequest, | |
| 287 args.Pass())); | |
| 288 break; | |
| 289 } | |
| 290 } | |
| 291 return request_id; | |
| 292 } | |
| 293 | |
| 294 WebViewPermissionHelper::SetPermissionResult | |
| 295 WebViewPermissionHelper::SetPermission( | |
| 296 int request_id, | |
| 297 PermissionResponseAction action, | |
| 298 const std::string& user_input) { | |
| 299 RequestMap::iterator request_itr = | |
| 300 pending_permission_requests_.find(request_id); | |
| 301 | |
| 302 if (request_itr == pending_permission_requests_.end()) | |
| 303 return SET_PERMISSION_INVALID; | |
| 304 | |
| 305 const PermissionResponseInfo& info = request_itr->second; | |
| 306 bool allow = (action == ALLOW) || | |
| 307 ((action == DEFAULT) && info.allowed_by_default); | |
| 308 | |
| 309 info.callback.Run(allow, user_input); | |
| 310 | |
| 311 // Only record user initiated (i.e. non-default) actions. | |
| 312 if (action != DEFAULT) | |
| 313 RecordUserInitiatedUMA(info, allow); | |
| 314 | |
| 315 pending_permission_requests_.erase(request_itr); | |
| 316 | |
| 317 return allow ? SET_PERMISSION_ALLOWED : SET_PERMISSION_DENIED; | |
| 318 } | |
| 319 | |
| 320 void WebViewPermissionHelper::CancelPendingPermissionRequest(int request_id) { | |
| 321 RequestMap::iterator request_itr = | |
| 322 pending_permission_requests_.find(request_id); | |
| 323 | |
| 324 if (request_itr == pending_permission_requests_.end()) | |
| 325 return; | |
| 326 | |
| 327 pending_permission_requests_.erase(request_itr); | |
| 328 } | |
| 329 | |
| 330 WebViewPermissionHelper::PermissionResponseInfo::PermissionResponseInfo() | |
| 331 : permission_type(WEB_VIEW_PERMISSION_TYPE_UNKNOWN), | |
| 332 allowed_by_default(false) { | |
| 333 } | |
| 334 | |
| 335 WebViewPermissionHelper::PermissionResponseInfo::PermissionResponseInfo( | |
| 336 const PermissionResponseCallback& callback, | |
| 337 WebViewPermissionType permission_type, | |
| 338 bool allowed_by_default) | |
| 339 : callback(callback), | |
| 340 permission_type(permission_type), | |
| 341 allowed_by_default(allowed_by_default) { | |
| 342 } | |
| 343 | |
| 344 WebViewPermissionHelper::PermissionResponseInfo::~PermissionResponseInfo() { | |
| 345 } | |
| 346 | |
| 347 } // namespace extensions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 505893002:
Revert of Move core web_view code to extensions. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master