| 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 "chrome/browser/guest_view/web_view/web_view_permission_helper.h" | |
| 6 | |
| 7 #include "chrome/browser/guest_view/web_view/chrome_web_view_permission_helper_d
elegate.h" | |
| 8 #include "chrome/browser/guest_view/web_view/web_view_constants.h" | |
| 9 #include "chrome/browser/guest_view/web_view/web_view_guest.h" | |
| 10 #include "chrome/browser/guest_view/web_view/web_view_permission_types.h" | |
| 11 #include "content/public/browser/render_process_host.h" | |
| 12 #include "content/public/browser/render_view_host.h" | |
| 13 #include "content/public/browser/user_metrics.h" | |
| 14 #include "extensions/browser/guest_view/web_view/web_view_permission_helper_dele
gate.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 // TODO(hanxi) : Create the delegate through ExtensionsAPIClient after | |
| 138 // moving WebViewPermissionHelper to extensions. | |
| 139 web_view_permission_helper_delegate_.reset( | |
| 140 new ChromeWebViewPermissionHelperDelegate(this)); | |
| 141 } | |
| 142 | |
| 143 WebViewPermissionHelper::~WebViewPermissionHelper() { | |
| 144 } | |
| 145 | |
| 146 // static | |
| 147 WebViewPermissionHelper* WebViewPermissionHelper::FromFrameID( | |
| 148 int render_process_id, | |
| 149 int render_frame_id) { | |
| 150 WebViewGuest* web_view_guest = WebViewGuest::FromFrameID( | |
| 151 render_process_id, render_frame_id); | |
| 152 if (!web_view_guest) { | |
| 153 return NULL; | |
| 154 } | |
| 155 return web_view_guest->web_view_permission_helper_.get(); | |
| 156 } | |
| 157 | |
| 158 // static | |
| 159 WebViewPermissionHelper* WebViewPermissionHelper::FromWebContents( | |
| 160 content::WebContents* web_contents) { | |
| 161 WebViewGuest* web_view_guest = WebViewGuest::FromWebContents(web_contents); | |
| 162 if (!web_view_guest) | |
| 163 return NULL; | |
| 164 return web_view_guest->web_view_permission_helper_.get(); | |
| 165 } | |
| 166 | |
| 167 #if defined(ENABLE_PLUGINS) | |
| 168 bool WebViewPermissionHelper::OnMessageReceived( | |
| 169 const IPC::Message& message, | |
| 170 content::RenderFrameHost* render_frame_host) { | |
| 171 return web_view_permission_helper_delegate_->OnMessageReceived( | |
| 172 message, render_frame_host); | |
| 173 } | |
| 174 | |
| 175 bool WebViewPermissionHelper::OnMessageReceived(const IPC::Message& message) { | |
| 176 return web_view_permission_helper_delegate_->OnMessageReceived(message); | |
| 177 } | |
| 178 #endif // defined(ENABLE_PLUGINS) | |
| 179 | |
| 180 void WebViewPermissionHelper::RequestMediaAccessPermission( | |
| 181 content::WebContents* source, | |
| 182 const content::MediaStreamRequest& request, | |
| 183 const content::MediaResponseCallback& callback) { | |
| 184 web_view_permission_helper_delegate_-> RequestMediaAccessPermission( | |
| 185 source, request, callback); | |
| 186 } | |
| 187 | |
| 188 void WebViewPermissionHelper::CanDownload( | |
| 189 content::RenderViewHost* render_view_host, | |
| 190 const GURL& url, | |
| 191 const std::string& request_method, | |
| 192 const base::Callback<void(bool)>& callback) { | |
| 193 web_view_permission_helper_delegate_->CanDownload( | |
| 194 render_view_host, url, request_method, callback); | |
| 195 } | |
| 196 | |
| 197 void WebViewPermissionHelper::RequestPointerLockPermission( | |
| 198 bool user_gesture, | |
| 199 bool last_unlocked_by_target, | |
| 200 const base::Callback<void(bool)>& callback) { | |
| 201 web_view_permission_helper_delegate_->RequestPointerLockPermission( | |
| 202 user_gesture, last_unlocked_by_target, callback); | |
| 203 } | |
| 204 | |
| 205 void WebViewPermissionHelper::RequestGeolocationPermission( | |
| 206 int bridge_id, | |
| 207 const GURL& requesting_frame, | |
| 208 bool user_gesture, | |
| 209 const base::Callback<void(bool)>& callback) { | |
| 210 web_view_permission_helper_delegate_->RequestGeolocationPermission( | |
| 211 bridge_id, requesting_frame, user_gesture, callback); | |
| 212 } | |
| 213 | |
| 214 void WebViewPermissionHelper::CancelGeolocationPermissionRequest( | |
| 215 int bridge_id) { | |
| 216 web_view_permission_helper_delegate_->CancelGeolocationPermissionRequest( | |
| 217 bridge_id); | |
| 218 } | |
| 219 | |
| 220 void WebViewPermissionHelper::RequestFileSystemPermission( | |
| 221 const GURL& url, | |
| 222 bool allowed_by_default, | |
| 223 const base::Callback<void(bool)>& callback) { | |
| 224 web_view_permission_helper_delegate_->RequestFileSystemPermission( | |
| 225 url, allowed_by_default, callback); | |
| 226 } | |
| 227 | |
| 228 void WebViewPermissionHelper::FileSystemAccessedAsync(int render_process_id, | |
| 229 int render_frame_id, | |
| 230 int request_id, | |
| 231 const GURL& url, | |
| 232 bool blocked_by_policy) { | |
| 233 web_view_permission_helper_delegate_->FileSystemAccessedAsync( | |
| 234 render_process_id, render_frame_id, request_id, url, blocked_by_policy); | |
| 235 } | |
| 236 | |
| 237 void WebViewPermissionHelper::FileSystemAccessedSync(int render_process_id, | |
| 238 int render_frame_id, | |
| 239 const GURL& url, | |
| 240 bool blocked_by_policy, | |
| 241 IPC::Message* reply_msg) { | |
| 242 web_view_permission_helper_delegate_->FileSystemAccessedSync( | |
| 243 render_process_id, render_frame_id, url, blocked_by_policy, reply_msg); | |
| 244 } | |
| 245 | |
| 246 int WebViewPermissionHelper::RequestPermission( | |
| 247 WebViewPermissionType permission_type, | |
| 248 const base::DictionaryValue& request_info, | |
| 249 const PermissionResponseCallback& callback, | |
| 250 bool allowed_by_default) { | |
| 251 // If there are too many pending permission requests then reject this request. | |
| 252 if (pending_permission_requests_.size() >= | |
| 253 webview::kMaxOutstandingPermissionRequests) { | |
| 254 // Let the stack unwind before we deny the permission request so that | |
| 255 // objects held by the permission request are not destroyed immediately | |
| 256 // after creation. This is to allow those same objects to be accessed again | |
| 257 // in the same scope without fear of use after freeing. | |
| 258 base::MessageLoop::current()->PostTask( | |
| 259 FROM_HERE, | |
| 260 base::Bind(&PermissionResponseCallback::Run, | |
| 261 base::Owned(new PermissionResponseCallback(callback)), | |
| 262 allowed_by_default, | |
| 263 std::string())); | |
| 264 return webview::kInvalidPermissionRequestID; | |
| 265 } | |
| 266 | |
| 267 int request_id = next_permission_request_id_++; | |
| 268 pending_permission_requests_[request_id] = | |
| 269 PermissionResponseInfo(callback, permission_type, allowed_by_default); | |
| 270 scoped_ptr<base::DictionaryValue> args(request_info.DeepCopy()); | |
| 271 args->SetInteger(webview::kRequestId, request_id); | |
| 272 switch (permission_type) { | |
| 273 case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: { | |
| 274 web_view_guest_->DispatchEventToEmbedder( | |
| 275 new GuestViewBase::Event(webview::kEventNewWindow, args.Pass())); | |
| 276 break; | |
| 277 } | |
| 278 case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: { | |
| 279 web_view_guest_->DispatchEventToEmbedder( | |
| 280 new GuestViewBase::Event(webview::kEventDialog, args.Pass())); | |
| 281 break; | |
| 282 } | |
| 283 default: { | |
| 284 args->SetString(webview::kPermission, | |
| 285 PermissionTypeToString(permission_type)); | |
| 286 web_view_guest_->DispatchEventToEmbedder(new GuestViewBase::Event( | |
| 287 webview::kEventPermissionRequest, | |
| 288 args.Pass())); | |
| 289 break; | |
| 290 } | |
| 291 } | |
| 292 return request_id; | |
| 293 } | |
| 294 | |
| 295 WebViewPermissionHelper::SetPermissionResult | |
| 296 WebViewPermissionHelper::SetPermission( | |
| 297 int request_id, | |
| 298 PermissionResponseAction action, | |
| 299 const std::string& user_input) { | |
| 300 RequestMap::iterator request_itr = | |
| 301 pending_permission_requests_.find(request_id); | |
| 302 | |
| 303 if (request_itr == pending_permission_requests_.end()) | |
| 304 return SET_PERMISSION_INVALID; | |
| 305 | |
| 306 const PermissionResponseInfo& info = request_itr->second; | |
| 307 bool allow = (action == ALLOW) || | |
| 308 ((action == DEFAULT) && info.allowed_by_default); | |
| 309 | |
| 310 info.callback.Run(allow, user_input); | |
| 311 | |
| 312 // Only record user initiated (i.e. non-default) actions. | |
| 313 if (action != DEFAULT) | |
| 314 RecordUserInitiatedUMA(info, allow); | |
| 315 | |
| 316 pending_permission_requests_.erase(request_itr); | |
| 317 | |
| 318 return allow ? SET_PERMISSION_ALLOWED : SET_PERMISSION_DENIED; | |
| 319 } | |
| 320 | |
| 321 void WebViewPermissionHelper::CancelPendingPermissionRequest(int request_id) { | |
| 322 RequestMap::iterator request_itr = | |
| 323 pending_permission_requests_.find(request_id); | |
| 324 | |
| 325 if (request_itr == pending_permission_requests_.end()) | |
| 326 return; | |
| 327 | |
| 328 pending_permission_requests_.erase(request_itr); | |
| 329 } | |
| 330 | |
| 331 WebViewPermissionHelper::PermissionResponseInfo::PermissionResponseInfo() | |
| 332 : permission_type(WEB_VIEW_PERMISSION_TYPE_UNKNOWN), | |
| 333 allowed_by_default(false) { | |
| 334 } | |
| 335 | |
| 336 WebViewPermissionHelper::PermissionResponseInfo::PermissionResponseInfo( | |
| 337 const PermissionResponseCallback& callback, | |
| 338 WebViewPermissionType permission_type, | |
| 339 bool allowed_by_default) | |
| 340 : callback(callback), | |
| 341 permission_type(permission_type), | |
| 342 allowed_by_default(allowed_by_default) { | |
| 343 } | |
| 344 | |
| 345 WebViewPermissionHelper::PermissionResponseInfo::~PermissionResponseInfo() { | |
| 346 } | |
| 347 | |
| 348 } // namespace extensions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 496873006:
Move core web_view code to extensions. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master