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_guest.h" 6 7 #include "base/message_loop/message_loop.h" 8 #include "base/strings/stringprintf.h" 9 #include "base/strings/utf_string_conversions.h" 10 #include "chrome/browser/chrome_notification_types.h" 11 #include "chrome/browser/content_settings/tab_specific_content_settings.h" 12 #include "chrome/browser/extensions/api/web_request/web_request_api.h" 13 #include "chrome/browser/extensions/api/webview/webview_api.h" 14 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h" 15 #include "chrome/browser/extensions/extension_renderer_state.h" 16 #include "chrome/browser/extensions/menu_manager.h" 17 #include "chrome/browser/extensions/script_executor.h" 18 #include "chrome/browser/favicon/favicon_tab_helper.h" 19 #include "chrome/browser/geolocation/geolocation_permission_context.h" 20 #include "chrome/browser/geolocation/geolocation_permission_context_factory.h" 21 #include "chrome/browser/guest_view/guest_view_constants.h" 22 #include "chrome/browser/guest_view/guest_view_manager.h" 23 #include "chrome/browser/guest_view/web_view/web_view_constants.h" 24 #include "chrome/browser/guest_view/web_view/web_view_permission_types.h" 25 #include "chrome/browser/renderer_context_menu/context_menu_delegate.h" 26 #include "chrome/browser/renderer_context_menu/render_view_context_menu.h" 27 #include "chrome/browser/ui/pdf/pdf_tab_helper.h" 28 #include "chrome/common/chrome_version_info.h" 29 #include "chrome/common/render_messages.h" 30 #include "content/public/browser/browser_thread.h" 31 #include "content/public/browser/child_process_security_policy.h" 32 #include "content/public/browser/host_zoom_map.h" 33 #include "content/public/browser/native_web_keyboard_event.h" 34 #include "content/public/browser/navigation_entry.h" 35 #include "content/public/browser/notification_details.h" 36 #include "content/public/browser/notification_service.h" 37 #include "content/public/browser/notification_source.h" 38 #include "content/public/browser/notification_types.h" 39 #include "content/public/browser/render_process_host.h" 40 #include "content/public/browser/render_view_host.h" 41 #include "content/public/browser/resource_request_details.h" 42 #include "content/public/browser/site_instance.h" 43 #include "content/public/browser/storage_partition.h" 44 #include "content/public/browser/user_metrics.h" 45 #include "content/public/browser/web_contents.h" 46 #include "content/public/browser/web_contents_delegate.h" 47 #include "content/public/common/media_stream_request.h" 48 #include "content/public/common/page_zoom.h" 49 #include "content/public/common/result_codes.h" 50 #include "content/public/common/stop_find_action.h" 51 #include "content/public/common/url_constants.h" 52 #include "extensions/common/constants.h" 53 #include "ipc/ipc_message_macros.h" 54 #include "net/base/escape.h" 55 #include "net/base/net_errors.h" 56 #include "third_party/WebKit/public/web/WebFindOptions.h" 57 #include "ui/base/models/simple_menu_model.h" 58 59 #if defined(ENABLE_PRINTING) 60 #if defined(ENABLE_FULL_PRINTING) 61 #include "chrome/browser/printing/print_preview_message_handler.h" 62 #include "chrome/browser/printing/print_view_manager.h" 63 #else 64 #include "chrome/browser/printing/print_view_manager_basic.h" 65 #endif // defined(ENABLE_FULL_PRINTING) 66 #endif // defined(ENABLE_PRINTING) 67 68 #if defined(ENABLE_PLUGINS) 69 #include "chrome/browser/guest_view/web_view/plugin_permission_helper.h" 70 #endif 71 72 #if defined(OS_CHROMEOS) 73 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h" 74 #endif 75 76 using base::UserMetricsAction; 77 using content::RenderFrameHost; 78 using content::WebContents; 79 80 namespace { 81 82 std::string WindowOpenDispositionToString( 83 WindowOpenDisposition window_open_disposition) { 84 switch (window_open_disposition) { 85 case IGNORE_ACTION: 86 return "ignore"; 87 case SAVE_TO_DISK: 88 return "save_to_disk"; 89 case CURRENT_TAB: 90 return "current_tab"; 91 case NEW_BACKGROUND_TAB: 92 return "new_background_tab"; 93 case NEW_FOREGROUND_TAB: 94 return "new_foreground_tab"; 95 case NEW_WINDOW: 96 return "new_window"; 97 case NEW_POPUP: 98 return "new_popup"; 99 default: 100 NOTREACHED() << "Unknown Window Open Disposition"; 101 return "ignore"; 102 } 103 } 104 105 static std::string TerminationStatusToString(base::TerminationStatus status) { 106 switch (status) { 107 case base::TERMINATION_STATUS_NORMAL_TERMINATION: 108 return "normal"; 109 case base::TERMINATION_STATUS_ABNORMAL_TERMINATION: 110 case base::TERMINATION_STATUS_STILL_RUNNING: 111 return "abnormal"; 112 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED: 113 return "killed"; 114 case base::TERMINATION_STATUS_PROCESS_CRASHED: 115 #if defined(OS_ANDROID) 116 case base::TERMINATION_STATUS_OOM_PROTECTED: 117 #endif 118 return "crashed"; 119 case base::TERMINATION_STATUS_MAX_ENUM: 120 break; 121 } 122 NOTREACHED() << "Unknown Termination Status."; 123 return "unknown"; 124 } 125 126 static std::string PermissionTypeToString(WebViewPermissionType type) { 127 switch (type) { 128 case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD: 129 return webview::kPermissionTypeDownload; 130 case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM: 131 return webview::kPermissionTypeFileSystem; 132 case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION: 133 return webview::kPermissionTypeGeolocation; 134 case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: 135 return webview::kPermissionTypeDialog; 136 case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN: 137 return webview::kPermissionTypeLoadPlugin; 138 case WEB_VIEW_PERMISSION_TYPE_MEDIA: 139 return webview::kPermissionTypeMedia; 140 case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: 141 return webview::kPermissionTypeNewWindow; 142 case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK: 143 return webview::kPermissionTypePointerLock; 144 default: 145 NOTREACHED(); 146 return std::string(); 147 } 148 } 149 150 std::string GetStoragePartitionIdFromSiteURL(const GURL& site_url) { 151 const std::string& partition_id = site_url.query(); 152 bool persist_storage = site_url.path().find("persist") != std::string::npos; 153 return (persist_storage ? webview::kPersistPrefix : "") + partition_id; 154 } 155 156 void RemoveWebViewEventListenersOnIOThread( 157 void* profile, 158 const std::string& extension_id, 159 int embedder_process_id, 160 int view_instance_id) { 161 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 162 ExtensionWebRequestEventRouter::GetInstance()->RemoveWebViewEventListeners( 163 profile, 164 extension_id, 165 embedder_process_id, 166 view_instance_id); 167 } 168 169 void AttachWebViewHelpers(WebContents* contents) { 170 FaviconTabHelper::CreateForWebContents(contents); 171 extensions::ChromeExtensionWebContentsObserver::CreateForWebContents( 172 contents); 173 #if defined(ENABLE_PLUGINS) 174 PluginPermissionHelper::CreateForWebContents(contents); 175 #endif 176 #if defined(ENABLE_PRINTING) 177 #if defined(ENABLE_FULL_PRINTING) 178 printing::PrintViewManager::CreateForWebContents(contents); 179 printing::PrintPreviewMessageHandler::CreateForWebContents(contents); 180 #else 181 printing::PrintViewManagerBasic::CreateForWebContents(contents); 182 #endif // defined(ENABLE_FULL_PRINTING) 183 #endif // defined(ENABLE_PRINTING) 184 PDFTabHelper::CreateForWebContents(contents); 185 } 186 187 } // namespace 188 189 WebViewGuest::WebViewGuest(int guest_instance_id, 190 WebContents* guest_web_contents, 191 const std::string& embedder_extension_id) 192 : GuestView<WebViewGuest>(guest_instance_id), 193 script_executor_(new extensions::ScriptExecutor(guest_web_contents, 194 &script_observers_)), 195 pending_context_menu_request_id_(0), 196 next_permission_request_id_(0), 197 is_overriding_user_agent_(false), 198 main_frame_id_(0), 199 chromevox_injected_(false), 200 find_helper_(this), 201 javascript_dialog_helper_(this) { 202 Init(guest_web_contents, embedder_extension_id); 203 notification_registrar_.Add( 204 this, content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME, 205 content::Source<WebContents>(guest_web_contents)); 206 207 notification_registrar_.Add( 208 this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT, 209 content::Source<WebContents>(guest_web_contents)); 210 211 #if defined(OS_CHROMEOS) 212 chromeos::AccessibilityManager* accessibility_manager = 213 chromeos::AccessibilityManager::Get(); 214 CHECK(accessibility_manager); 215 accessibility_subscription_ = accessibility_manager->RegisterCallback( 216 base::Bind(&WebViewGuest::OnAccessibilityStatusChanged, 217 base::Unretained(this))); 218 #endif 219 220 AttachWebViewHelpers(guest_web_contents); 221 } 222 223 // static 224 bool WebViewGuest::GetGuestPartitionConfigForSite( 225 const GURL& site, 226 std::string* partition_domain, 227 std::string* partition_name, 228 bool* in_memory) { 229 if (!site.SchemeIs(content::kGuestScheme)) 230 return false; 231 232 // Since guest URLs are only used for packaged apps, there must be an app 233 // id in the URL. 234 CHECK(site.has_host()); 235 *partition_domain = site.host(); 236 // Since persistence is optional, the path must either be empty or the 237 // literal string. 238 *in_memory = (site.path() != "/persist"); 239 // The partition name is user supplied value, which we have encoded when the 240 // URL was created, so it needs to be decoded. 241 *partition_name = 242 net::UnescapeURLComponent(site.query(), net::UnescapeRule::NORMAL); 243 return true; 244 } 245 246 // static 247 const char WebViewGuest::Type[] = "webview"; 248 249 // static 250 int WebViewGuest::GetViewInstanceId(WebContents* contents) { 251 WebViewGuest* guest = FromWebContents(contents); 252 if (!guest) 253 return guestview::kInstanceIDNone; 254 255 return guest->view_instance_id(); 256 } 257 258 // static 259 void WebViewGuest::ParsePartitionParam( 260 const base::DictionaryValue* extra_params, 261 std::string* storage_partition_id, 262 bool* persist_storage) { 263 std::string partition_str; 264 if (!extra_params->GetString(webview::kStoragePartitionId, &partition_str)) { 265 return; 266 } 267 268 // Since the "persist:" prefix is in ASCII, StartsWith will work fine on 269 // UTF-8 encoded |partition_id|. If the prefix is a match, we can safely 270 // remove the prefix without splicing in the middle of a multi-byte codepoint. 271 // We can use the rest of the string as UTF-8 encoded one. 272 if (StartsWithASCII(partition_str, "persist:", true)) { 273 size_t index = partition_str.find(":"); 274 CHECK(index != std::string::npos); 275 // It is safe to do index + 1, since we tested for the full prefix above. 276 *storage_partition_id = partition_str.substr(index + 1); 277 278 if (storage_partition_id->empty()) { 279 // TODO(lazyboy): Better way to deal with this error. 280 return; 281 } 282 *persist_storage = true; 283 } else { 284 *storage_partition_id = partition_str; 285 *persist_storage = false; 286 } 287 } 288 289 // static 290 void WebViewGuest::RecordUserInitiatedUMA(const PermissionResponseInfo& info, 291 bool allow) { 292 if (allow) { 293 // Note that |allow| == true means the embedder explicitly allowed the 294 // request. For some requests they might still fail. An example of such 295 // scenario would be: an embedder allows geolocation request but doesn't 296 // have geolocation access on its own. 297 switch (info.permission_type) { 298 case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD: 299 content::RecordAction( 300 UserMetricsAction("WebView.PermissionAllow.Download")); 301 break; 302 case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM: 303 content::RecordAction( 304 UserMetricsAction("WebView.PermissionAllow.FileSystem")); 305 break; 306 case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION: 307 content::RecordAction( 308 UserMetricsAction("WebView.PermissionAllow.Geolocation")); 309 break; 310 case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: 311 content::RecordAction( 312 UserMetricsAction("WebView.PermissionAllow.JSDialog")); 313 break; 314 case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN: 315 content::RecordAction( 316 UserMetricsAction("WebView.Guest.PermissionAllow.PluginLoad")); 317 case WEB_VIEW_PERMISSION_TYPE_MEDIA: 318 content::RecordAction( 319 UserMetricsAction("WebView.PermissionAllow.Media")); 320 break; 321 case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: 322 content::RecordAction( 323 UserMetricsAction("BrowserPlugin.PermissionAllow.NewWindow")); 324 break; 325 case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK: 326 content::RecordAction( 327 UserMetricsAction("WebView.PermissionAllow.PointerLock")); 328 break; 329 default: 330 break; 331 } 332 } else { 333 switch (info.permission_type) { 334 case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD: 335 content::RecordAction( 336 UserMetricsAction("WebView.PermissionDeny.Download")); 337 break; 338 case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM: 339 content::RecordAction( 340 UserMetricsAction("WebView.PermissionDeny.FileSystem")); 341 break; 342 case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION: 343 content::RecordAction( 344 UserMetricsAction("WebView.PermissionDeny.Geolocation")); 345 break; 346 case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: 347 content::RecordAction( 348 UserMetricsAction("WebView.PermissionDeny.JSDialog")); 349 break; 350 case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN: 351 content::RecordAction( 352 UserMetricsAction("WebView.Guest.PermissionDeny.PluginLoad")); 353 break; 354 case WEB_VIEW_PERMISSION_TYPE_MEDIA: 355 content::RecordAction( 356 UserMetricsAction("WebView.PermissionDeny.Media")); 357 break; 358 case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: 359 content::RecordAction( 360 UserMetricsAction("BrowserPlugin.PermissionDeny.NewWindow")); 361 break; 362 case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK: 363 content::RecordAction( 364 UserMetricsAction("WebView.PermissionDeny.PointerLock")); 365 break; 366 default: 367 break; 368 } 369 } 370 } 371 372 // static 373 scoped_ptr<base::ListValue> WebViewGuest::MenuModelToValue( 374 const ui::SimpleMenuModel& menu_model) { 375 scoped_ptr<base::ListValue> items(new base::ListValue()); 376 for (int i = 0; i < menu_model.GetItemCount(); ++i) { 377 base::DictionaryValue* item_value = new base::DictionaryValue(); 378 // TODO(lazyboy): We need to expose some kind of enum equivalent of 379 // |command_id| instead of plain integers. 380 item_value->SetInteger(webview::kMenuItemCommandId, 381 menu_model.GetCommandIdAt(i)); 382 item_value->SetString(webview::kMenuItemLabel, menu_model.GetLabelAt(i)); 383 items->Append(item_value); 384 } 385 return items.Pass(); 386 } 387 388 void WebViewGuest::DidAttachToEmbedder() { 389 std::string name; 390 if (extra_params()->GetString(webview::kName, &name)) { 391 // If the guest window's name is empty, then the WebView tag's name is 392 // assigned. Otherwise, the guest window's name takes precedence over the 393 // WebView tag's name. 394 if (name_.empty()) 395 name_ = name; 396 } 397 ReportFrameNameChange(name_); 398 399 std::string user_agent_override; 400 if (extra_params()->GetString(webview::kParameterUserAgentOverride, 401 &user_agent_override)) { 402 SetUserAgentOverride(user_agent_override); 403 } else { 404 SetUserAgentOverride(""); 405 } 406 407 std::string src; 408 if (extra_params()->GetString("src", &src) && !src.empty()) 409 NavigateGuest(src); 410 411 if (GetOpener()) { 412 // We need to do a navigation here if the target URL has changed between 413 // the time the WebContents was created and the time it was attached. 414 // We also need to do an initial navigation if a RenderView was never 415 // created for the new window in cases where there is no referrer. 416 PendingWindowMap::iterator it = 417 GetOpener()->pending_new_windows_.find(this); 418 if (it != GetOpener()->pending_new_windows_.end()) { 419 const NewWindowInfo& new_window_info = it->second; 420 if (new_window_info.changed || !guest_web_contents()->HasOpener()) 421 NavigateGuest(new_window_info.url.spec()); 422 } else { 423 NOTREACHED(); 424 } 425 426 // Once a new guest is attached to the DOM of the embedder page, then the 427 // lifetime of the new guest is no longer managed by the opener guest. 428 GetOpener()->pending_new_windows_.erase(this); 429 } 430 } 431 432 void WebViewGuest::DidStopLoading() { 433 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 434 DispatchEvent(new GuestViewBase::Event(webview::kEventLoadStop, args.Pass())); 435 } 436 437 void WebViewGuest::EmbedderDestroyed() { 438 // TODO(fsamuel): WebRequest event listeners for <webview> should survive 439 // reparenting of a <webview> within a single embedder. Right now, we keep 440 // around the browser state for the listener for the lifetime of the embedder. 441 // Ideally, the lifetime of the listeners should match the lifetime of the 442 // <webview> DOM node. Once http://crbug.com/156219 is resolved we can move 443 // the call to RemoveWebViewEventListenersOnIOThread back to 444 // WebViewGuest::WebContentsDestroyed. 445 content::BrowserThread::PostTask( 446 content::BrowserThread::IO, 447 FROM_HERE, 448 base::Bind( 449 &RemoveWebViewEventListenersOnIOThread, 450 browser_context(), embedder_extension_id(), 451 embedder_render_process_id(), 452 view_instance_id())); 453 } 454 455 void WebViewGuest::GuestDestroyed() { 456 // Clean up custom context menu items for this guest. 457 extensions::MenuManager* menu_manager = extensions::MenuManager::Get( 458 Profile::FromBrowserContext(browser_context())); 459 menu_manager->RemoveAllContextItems(extensions::MenuItem::ExtensionKey( 460 embedder_extension_id(), view_instance_id())); 461 462 RemoveWebViewFromExtensionRendererState(web_contents()); 463 } 464 465 bool WebViewGuest::IsDragAndDropEnabled() const { 466 return true; 467 } 468 469 void WebViewGuest::WillDestroy() { 470 if (!attached() && GetOpener()) 471 GetOpener()->pending_new_windows_.erase(this); 472 DestroyUnattachedWindows(); 473 } 474 475 bool WebViewGuest::AddMessageToConsole(WebContents* source, 476 int32 level, 477 const base::string16& message, 478 int32 line_no, 479 const base::string16& source_id) { 480 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 481 // Log levels are from base/logging.h: LogSeverity. 482 args->SetInteger(webview::kLevel, level); 483 args->SetString(webview::kMessage, message); 484 args->SetInteger(webview::kLine, line_no); 485 args->SetString(webview::kSourceId, source_id); 486 DispatchEvent( 487 new GuestViewBase::Event(webview::kEventConsoleMessage, args.Pass())); 488 return true; 489 } 490 491 void WebViewGuest::CloseContents(WebContents* source) { 492 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 493 DispatchEvent(new GuestViewBase::Event(webview::kEventClose, args.Pass())); 494 } 495 496 void WebViewGuest::FindReply(WebContents* source, 497 int request_id, 498 int number_of_matches, 499 const gfx::Rect& selection_rect, 500 int active_match_ordinal, 501 bool final_update) { 502 find_helper_.FindReply(request_id, number_of_matches, selection_rect, 503 active_match_ordinal, final_update); 504 } 505 506 bool WebViewGuest::HandleContextMenu( 507 const content::ContextMenuParams& params) { 508 ContextMenuDelegate* menu_delegate = 509 ContextMenuDelegate::FromWebContents(guest_web_contents()); 510 DCHECK(menu_delegate); 511 512 pending_menu_ = menu_delegate->BuildMenu(guest_web_contents(), params); 513 514 // Pass it to embedder. 515 int request_id = ++pending_context_menu_request_id_; 516 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 517 scoped_ptr<base::ListValue> items = 518 MenuModelToValue(pending_menu_->menu_model()); 519 args->Set(webview::kContextMenuItems, items.release()); 520 args->SetInteger(webview::kRequestId, request_id); 521 DispatchEvent(new GuestViewBase::Event(webview::kEventContextMenu, 522 args.Pass())); 523 return true; 524 } 525 526 void WebViewGuest::HandleKeyboardEvent( 527 WebContents* source, 528 const content::NativeWebKeyboardEvent& event) { 529 if (!attached()) 530 return; 531 532 if (HandleKeyboardShortcuts(event)) 533 return; 534 535 // Send the unhandled keyboard events back to the embedder to reprocess them. 536 // TODO(fsamuel): This introduces the possibility of out-of-order keyboard 537 // events because the guest may be arbitrarily delayed when responding to 538 // keyboard events. In that time, the embedder may have received and processed 539 // additional key events. This needs to be fixed as soon as possible. 540 // See http://crbug.com/229882. 541 embedder_web_contents()->GetDelegate()->HandleKeyboardEvent( 542 web_contents(), event); 543 } 544 545 void WebViewGuest::LoadProgressChanged(content::WebContents* source, 546 double progress) { 547 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 548 args->SetString(guestview::kUrl, guest_web_contents()->GetURL().spec()); 549 args->SetDouble(webview::kProgress, progress); 550 DispatchEvent( 551 new GuestViewBase::Event(webview::kEventLoadProgress, args.Pass())); 552 } 553 554 void WebViewGuest::LoadAbort(bool is_top_level, 555 const GURL& url, 556 const std::string& error_type) { 557 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 558 args->SetBoolean(guestview::kIsTopLevel, is_top_level); 559 args->SetString(guestview::kUrl, url.possibly_invalid_spec()); 560 args->SetString(guestview::kReason, error_type); 561 DispatchEvent( 562 new GuestViewBase::Event(webview::kEventLoadAbort, args.Pass())); 563 } 564 565 void WebViewGuest::OnUpdateFrameName(bool is_top_level, 566 const std::string& name) { 567 if (!is_top_level) 568 return; 569 570 if (name_ == name) 571 return; 572 573 ReportFrameNameChange(name); 574 } 575 576 WebViewGuest* WebViewGuest::CreateNewGuestWindow( 577 const content::OpenURLParams& params) { 578 GuestViewManager* guest_manager = 579 GuestViewManager::FromBrowserContext(browser_context()); 580 // Allocate a new instance ID for the new guest. 581 int instance_id = guest_manager->GetNextInstanceID(); 582 583 // Set the attach params to use the same partition as the opener. 584 // We pull the partition information from the site's URL, which is of the 585 // form guest://site/{persist}?{partition_name}. 586 const GURL& site_url = guest_web_contents()->GetSiteInstance()->GetSiteURL(); 587 scoped_ptr<base::DictionaryValue> create_params(extra_params()->DeepCopy()); 588 const std::string storage_partition_id = 589 GetStoragePartitionIdFromSiteURL(site_url); 590 create_params->SetString(webview::kStoragePartitionId, storage_partition_id); 591 592 WebContents* new_guest_web_contents = 593 guest_manager->CreateGuest(guest_web_contents()->GetSiteInstance(), 594 instance_id, 595 create_params.Pass()); 596 WebViewGuest* new_guest = 597 WebViewGuest::FromWebContents(new_guest_web_contents); 598 new_guest->SetOpener(this); 599 600 // Take ownership of |new_guest|. 601 pending_new_windows_.insert( 602 std::make_pair(new_guest, NewWindowInfo(params.url, std::string()))); 603 604 // Request permission to show the new window. 605 RequestNewWindowPermission(params.disposition, gfx::Rect(), 606 params.user_gesture, 607 new_guest->guest_web_contents()); 608 609 return new_guest; 610 } 611 612 // TODO(fsamuel): Find a reliable way to test the 'responsive' and 613 // 'unresponsive' events. 614 void WebViewGuest::RendererResponsive(content::WebContents* source) { 615 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 616 args->SetInteger(webview::kProcessId, 617 guest_web_contents()->GetRenderProcessHost()->GetID()); 618 DispatchEvent( 619 new GuestViewBase::Event(webview::kEventResponsive, args.Pass())); 620 } 621 622 void WebViewGuest::RendererUnresponsive(content::WebContents* source) { 623 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 624 args->SetInteger(webview::kProcessId, 625 guest_web_contents()->GetRenderProcessHost()->GetID()); 626 DispatchEvent( 627 new GuestViewBase::Event(webview::kEventUnresponsive, args.Pass())); 628 } 629 630 void WebViewGuest::Observe(int type, 631 const content::NotificationSource& source, 632 const content::NotificationDetails& details) { 633 switch (type) { 634 case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME: { 635 DCHECK_EQ(content::Source<WebContents>(source).ptr(), 636 guest_web_contents()); 637 if (content::Source<WebContents>(source).ptr() == guest_web_contents()) 638 LoadHandlerCalled(); 639 break; 640 } 641 case content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT: { 642 DCHECK_EQ(content::Source<WebContents>(source).ptr(), 643 guest_web_contents()); 644 content::ResourceRedirectDetails* resource_redirect_details = 645 content::Details<content::ResourceRedirectDetails>(details).ptr(); 646 bool is_top_level = 647 resource_redirect_details->resource_type == ResourceType::MAIN_FRAME; 648 LoadRedirect(resource_redirect_details->url, 649 resource_redirect_details->new_url, 650 is_top_level); 651 break; 652 } 653 default: 654 NOTREACHED() << "Unexpected notification sent."; 655 break; 656 } 657 } 658 659 double WebViewGuest::GetZoom() { 660 return current_zoom_factor_; 661 } 662 663 void WebViewGuest::Find( 664 const base::string16& search_text, 665 const blink::WebFindOptions& options, 666 scoped_refptr<extensions::WebviewFindFunction> find_function) { 667 find_helper_.Find(guest_web_contents(), search_text, options, find_function); 668 } 669 670 void WebViewGuest::StopFinding(content::StopFindAction action) { 671 find_helper_.CancelAllFindSessions(); 672 guest_web_contents()->StopFinding(action); 673 } 674 675 void WebViewGuest::Go(int relative_index) { 676 guest_web_contents()->GetController().GoToOffset(relative_index); 677 } 678 679 void WebViewGuest::Reload() { 680 // TODO(fsamuel): Don't check for repost because we don't want to show 681 // Chromium's repost warning. We might want to implement a separate API 682 // for registering a callback if a repost is about to happen. 683 guest_web_contents()->GetController().Reload(false); 684 } 685 686 void WebViewGuest::RequestFileSystemPermission( 687 const GURL& url, 688 bool allowed_by_default, 689 const base::Callback<void(bool)>& callback) { 690 base::DictionaryValue request_info; 691 request_info.Set(guestview::kUrl, base::Value::CreateStringValue(url.spec())); 692 RequestPermission( 693 WEB_VIEW_PERMISSION_TYPE_FILESYSTEM, 694 request_info, 695 base::Bind(&WebViewGuest::OnWebViewFileSystemPermissionResponse, 696 base::Unretained(this), 697 callback), 698 allowed_by_default); 699 } 700 701 void WebViewGuest::OnWebViewFileSystemPermissionResponse( 702 const base::Callback<void(bool)>& callback, 703 bool allow, 704 const std::string& user_input) { 705 callback.Run(allow && attached()); 706 } 707 708 void WebViewGuest::RequestGeolocationPermission( 709 int bridge_id, 710 const GURL& requesting_frame, 711 bool user_gesture, 712 const base::Callback<void(bool)>& callback) { 713 base::DictionaryValue request_info; 714 request_info.Set(guestview::kUrl, 715 base::Value::CreateStringValue(requesting_frame.spec())); 716 request_info.Set(guestview::kUserGesture, 717 base::Value::CreateBooleanValue(user_gesture)); 718 719 // It is safe to hold an unretained pointer to WebViewGuest because this 720 // callback is called from WebViewGuest::SetPermission. 721 const PermissionResponseCallback permission_callback = 722 base::Bind(&WebViewGuest::OnWebViewGeolocationPermissionResponse, 723 base::Unretained(this), 724 bridge_id, 725 user_gesture, 726 callback); 727 int request_id = RequestPermission( 728 WEB_VIEW_PERMISSION_TYPE_GEOLOCATION, 729 request_info, 730 permission_callback, 731 false /* allowed_by_default */); 732 bridge_id_to_request_id_map_[bridge_id] = request_id; 733 } 734 735 void WebViewGuest::OnWebViewGeolocationPermissionResponse( 736 int bridge_id, 737 bool user_gesture, 738 const base::Callback<void(bool)>& callback, 739 bool allow, 740 const std::string& user_input) { 741 // The <webview> embedder has allowed the permission. We now need to make sure 742 // that the embedder has geolocation permission. 743 RemoveBridgeID(bridge_id); 744 745 if (!allow || !attached()) { 746 callback.Run(false); 747 return; 748 } 749 750 Profile* profile = Profile::FromBrowserContext(browser_context()); 751 GeolocationPermissionContextFactory::GetForProfile(profile)-> 752 RequestGeolocationPermission( 753 embedder_web_contents(), 754 // The geolocation permission request here is not initiated 755 // through WebGeolocationPermissionRequest. We are only interested 756 // in the fact whether the embedder/app has geolocation 757 // permission. Therefore we use an invalid |bridge_id|. 758 -1, 759 embedder_web_contents()->GetLastCommittedURL(), 760 user_gesture, 761 callback, 762 NULL); 763 } 764 765 void WebViewGuest::CancelGeolocationPermissionRequest(int bridge_id) { 766 int request_id = RemoveBridgeID(bridge_id); 767 RequestMap::iterator request_itr = 768 pending_permission_requests_.find(request_id); 769 770 if (request_itr == pending_permission_requests_.end()) 771 return; 772 773 pending_permission_requests_.erase(request_itr); 774 } 775 776 void WebViewGuest::OnWebViewMediaPermissionResponse( 777 const content::MediaStreamRequest& request, 778 const content::MediaResponseCallback& callback, 779 bool allow, 780 const std::string& user_input) { 781 if (!allow || !attached()) { 782 // Deny the request. 783 callback.Run(content::MediaStreamDevices(), 784 content::MEDIA_DEVICE_INVALID_STATE, 785 scoped_ptr<content::MediaStreamUI>()); 786 return; 787 } 788 if (!embedder_web_contents()->GetDelegate()) 789 return; 790 791 embedder_web_contents()->GetDelegate()-> 792 RequestMediaAccessPermission(embedder_web_contents(), request, callback); 793 } 794 795 void WebViewGuest::OnWebViewDownloadPermissionResponse( 796 const base::Callback<void(bool)>& callback, 797 bool allow, 798 const std::string& user_input) { 799 callback.Run(allow && attached()); 800 } 801 802 void WebViewGuest::OnWebViewPointerLockPermissionResponse( 803 const base::Callback<void(bool)>& callback, 804 bool allow, 805 const std::string& user_input) { 806 callback.Run(allow && attached()); 807 } 808 809 WebViewGuest::SetPermissionResult WebViewGuest::SetPermission( 810 int request_id, 811 PermissionResponseAction action, 812 const std::string& user_input) { 813 RequestMap::iterator request_itr = 814 pending_permission_requests_.find(request_id); 815 816 if (request_itr == pending_permission_requests_.end()) 817 return SET_PERMISSION_INVALID; 818 819 const PermissionResponseInfo& info = request_itr->second; 820 bool allow = (action == ALLOW) || 821 ((action == DEFAULT) && info.allowed_by_default); 822 823 info.callback.Run(allow, user_input); 824 825 // Only record user initiated (i.e. non-default) actions. 826 if (action != DEFAULT) 827 RecordUserInitiatedUMA(info, allow); 828 829 pending_permission_requests_.erase(request_itr); 830 831 return allow ? SET_PERMISSION_ALLOWED : SET_PERMISSION_DENIED; 832 } 833 834 void WebViewGuest::SetUserAgentOverride( 835 const std::string& user_agent_override) { 836 if (!attached()) 837 return; 838 is_overriding_user_agent_ = !user_agent_override.empty(); 839 if (is_overriding_user_agent_) { 840 content::RecordAction(UserMetricsAction("WebView.Guest.OverrideUA")); 841 } 842 guest_web_contents()->SetUserAgentOverride(user_agent_override); 843 } 844 845 void WebViewGuest::Stop() { 846 guest_web_contents()->Stop(); 847 } 848 849 void WebViewGuest::Terminate() { 850 content::RecordAction(UserMetricsAction("WebView.Guest.Terminate")); 851 base::ProcessHandle process_handle = 852 guest_web_contents()->GetRenderProcessHost()->GetHandle(); 853 if (process_handle) 854 base::KillProcess(process_handle, content::RESULT_CODE_KILLED, false); 855 } 856 857 bool WebViewGuest::ClearData(const base::Time remove_since, 858 uint32 removal_mask, 859 const base::Closure& callback) { 860 content::RecordAction(UserMetricsAction("WebView.Guest.ClearData")); 861 content::StoragePartition* partition = 862 content::BrowserContext::GetStoragePartition( 863 guest_web_contents()->GetBrowserContext(), 864 guest_web_contents()->GetSiteInstance()); 865 866 if (!partition) 867 return false; 868 869 partition->ClearData( 870 removal_mask, 871 content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL, 872 GURL(), 873 content::StoragePartition::OriginMatcherFunction(), 874 remove_since, 875 base::Time::Now(), 876 callback); 877 return true; 878 } 879 880 // static 881 void WebViewGuest::FileSystemAccessedAsync(int render_process_id, 882 int render_frame_id, 883 int request_id, 884 const GURL& url, 885 bool blocked_by_policy) { 886 WebViewGuest* guest = 887 WebViewGuest::FromFrameID(render_process_id, render_frame_id); 888 DCHECK(guest); 889 guest->RequestFileSystemPermission( 890 url, 891 !blocked_by_policy, 892 base::Bind(&WebViewGuest::FileSystemAccessedAsyncResponse, 893 render_process_id, 894 render_frame_id, 895 request_id, 896 url)); 897 } 898 899 // static 900 void WebViewGuest::FileSystemAccessedAsyncResponse(int render_process_id, 901 int render_frame_id, 902 int request_id, 903 const GURL& url, 904 bool allowed) { 905 TabSpecificContentSettings::FileSystemAccessed( 906 render_process_id, render_frame_id, url, !allowed); 907 content::RenderFrameHost* render_frame_host = 908 content::RenderFrameHost::FromID(render_process_id, render_frame_id); 909 if (!render_frame_host) 910 return; 911 render_frame_host->Send( 912 new ChromeViewMsg_RequestFileSystemAccessAsyncResponse( 913 render_frame_id, request_id, allowed)); 914 } 915 916 // static 917 void WebViewGuest::FileSystemAccessedSync(int render_process_id, 918 int render_frame_id, 919 const GURL& url, 920 bool blocked_by_policy, 921 IPC::Message* reply_msg) { 922 WebViewGuest* guest = 923 WebViewGuest::FromFrameID(render_process_id, render_frame_id); 924 DCHECK(guest); 925 guest->RequestFileSystemPermission( 926 url, 927 !blocked_by_policy, 928 base::Bind(&WebViewGuest::FileSystemAccessedSyncResponse, 929 render_process_id, 930 render_frame_id, 931 url, 932 reply_msg)); 933 } 934 935 // static 936 void WebViewGuest::FileSystemAccessedSyncResponse(int render_process_id, 937 int render_frame_id, 938 const GURL& url, 939 IPC::Message* reply_msg, 940 bool allowed) { 941 TabSpecificContentSettings::FileSystemAccessed( 942 render_process_id, render_frame_id, url, !allowed); 943 ChromeViewHostMsg_RequestFileSystemAccessSync::WriteReplyParams(reply_msg, 944 allowed); 945 content::RenderFrameHost* render_frame_host = 946 content::RenderFrameHost::FromID(render_process_id, render_frame_id); 947 if (!render_frame_id) 948 return; 949 render_frame_host->Send(reply_msg); 950 } 951 952 WebViewGuest::~WebViewGuest() { 953 } 954 955 void WebViewGuest::DidCommitProvisionalLoadForFrame( 956 int64 frame_id, 957 const base::string16& frame_unique_name, 958 bool is_main_frame, 959 const GURL& url, 960 content::PageTransition transition_type, 961 content::RenderViewHost* render_view_host) { 962 find_helper_.CancelAllFindSessions(); 963 964 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 965 args->SetString(guestview::kUrl, url.spec()); 966 args->SetBoolean(guestview::kIsTopLevel, is_main_frame); 967 args->SetInteger(webview::kInternalCurrentEntryIndex, 968 guest_web_contents()->GetController().GetCurrentEntryIndex()); 969 args->SetInteger(webview::kInternalEntryCount, 970 guest_web_contents()->GetController().GetEntryCount()); 971 args->SetInteger(webview::kInternalProcessId, 972 guest_web_contents()->GetRenderProcessHost()->GetID()); 973 DispatchEvent( 974 new GuestViewBase::Event(webview::kEventLoadCommit, args.Pass())); 975 976 // Update the current zoom factor for the new page. 977 current_zoom_factor_ = content::ZoomLevelToZoomFactor( 978 content::HostZoomMap::GetZoomLevel(guest_web_contents())); 979 980 if (is_main_frame) { 981 chromevox_injected_ = false; 982 main_frame_id_ = frame_id; 983 } 984 } 985 986 void WebViewGuest::DidFailProvisionalLoad( 987 int64 frame_id, 988 const base::string16& frame_unique_name, 989 bool is_main_frame, 990 const GURL& validated_url, 991 int error_code, 992 const base::string16& error_description, 993 content::RenderViewHost* render_view_host) { 994 // Translate the |error_code| into an error string. 995 std::string error_type(net::ErrorToString(error_code)); 996 DCHECK(StartsWithASCII(error_type, "net::", true)); 997 error_type.erase(0, 5); 998 LoadAbort(is_main_frame, validated_url, error_type); 999 } 1000 1001 void WebViewGuest::DidStartProvisionalLoadForFrame( 1002 int64 frame_id, 1003 int64 parent_frame_id, 1004 bool is_main_frame, 1005 const GURL& validated_url, 1006 bool is_error_page, 1007 bool is_iframe_srcdoc, 1008 content::RenderViewHost* render_view_host) { 1009 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 1010 args->SetString(guestview::kUrl, validated_url.spec()); 1011 args->SetBoolean(guestview::kIsTopLevel, is_main_frame); 1012 DispatchEvent( 1013 new GuestViewBase::Event(webview::kEventLoadStart, args.Pass())); 1014 } 1015 1016 void WebViewGuest::DocumentLoadedInFrame( 1017 int64 frame_id, 1018 content::RenderViewHost* render_view_host) { 1019 if (frame_id == main_frame_id_) 1020 InjectChromeVoxIfNeeded(render_view_host); 1021 } 1022 1023 bool WebViewGuest::OnMessageReceived(const IPC::Message& message, 1024 RenderFrameHost* render_frame_host) { 1025 bool handled = true; 1026 IPC_BEGIN_MESSAGE_MAP(WebViewGuest, message) 1027 IPC_MESSAGE_HANDLER(ChromeViewHostMsg_UpdateFrameName, OnUpdateFrameName) 1028 IPC_MESSAGE_UNHANDLED(handled = false) 1029 IPC_END_MESSAGE_MAP() 1030 return handled; 1031 } 1032 1033 void WebViewGuest::RenderProcessGone(base::TerminationStatus status) { 1034 // Cancel all find sessions in progress. 1035 find_helper_.CancelAllFindSessions(); 1036 1037 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 1038 args->SetInteger(webview::kProcessId, 1039 guest_web_contents()->GetRenderProcessHost()->GetID()); 1040 args->SetString(webview::kReason, TerminationStatusToString(status)); 1041 DispatchEvent(new GuestViewBase::Event(webview::kEventExit, args.Pass())); 1042 } 1043 1044 void WebViewGuest::UserAgentOverrideSet(const std::string& user_agent) { 1045 if (!attached()) 1046 return; 1047 content::NavigationController& controller = 1048 guest_web_contents()->GetController(); 1049 content::NavigationEntry* entry = controller.GetVisibleEntry(); 1050 if (!entry) 1051 return; 1052 entry->SetIsOverridingUserAgent(!user_agent.empty()); 1053 guest_web_contents()->GetController().Reload(false); 1054 } 1055 1056 void WebViewGuest::RenderViewReady() { 1057 // The guest RenderView should always live in an isolated guest process. 1058 CHECK(guest_web_contents()->GetRenderProcessHost()->IsIsolatedGuest()); 1059 Send(new ChromeViewMsg_SetName(guest_web_contents()->GetRoutingID(), name_)); 1060 } 1061 1062 void WebViewGuest::ReportFrameNameChange(const std::string& name) { 1063 name_ = name; 1064 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 1065 args->SetString(webview::kName, name); 1066 DispatchEvent( 1067 new GuestViewBase::Event(webview::kEventFrameNameChanged, args.Pass())); 1068 } 1069 1070 void WebViewGuest::LoadHandlerCalled() { 1071 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 1072 DispatchEvent( 1073 new GuestViewBase::Event(webview::kEventContentLoad, args.Pass())); 1074 } 1075 1076 void WebViewGuest::LoadRedirect(const GURL& old_url, 1077 const GURL& new_url, 1078 bool is_top_level) { 1079 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 1080 args->SetBoolean(guestview::kIsTopLevel, is_top_level); 1081 args->SetString(webview::kNewURL, new_url.spec()); 1082 args->SetString(webview::kOldURL, old_url.spec()); 1083 DispatchEvent( 1084 new GuestViewBase::Event(webview::kEventLoadRedirect, args.Pass())); 1085 } 1086 1087 void WebViewGuest::AddWebViewToExtensionRendererState() { 1088 const GURL& site_url = guest_web_contents()->GetSiteInstance()->GetSiteURL(); 1089 std::string partition_domain; 1090 std::string partition_id; 1091 bool in_memory; 1092 if (!GetGuestPartitionConfigForSite( 1093 site_url, &partition_domain, &partition_id, &in_memory)) { 1094 NOTREACHED(); 1095 return; 1096 } 1097 DCHECK(embedder_extension_id() == partition_domain); 1098 1099 ExtensionRendererState::WebViewInfo web_view_info; 1100 web_view_info.embedder_process_id = embedder_render_process_id(); 1101 web_view_info.instance_id = view_instance_id(); 1102 web_view_info.partition_id = partition_id; 1103 web_view_info.embedder_extension_id = embedder_extension_id(); 1104 1105 content::BrowserThread::PostTask( 1106 content::BrowserThread::IO, 1107 FROM_HERE, 1108 base::Bind(&ExtensionRendererState::AddWebView, 1109 base::Unretained(ExtensionRendererState::GetInstance()), 1110 guest_web_contents()->GetRenderProcessHost()->GetID(), 1111 guest_web_contents()->GetRoutingID(), 1112 web_view_info)); 1113 } 1114 1115 // static 1116 void WebViewGuest::RemoveWebViewFromExtensionRendererState( 1117 WebContents* web_contents) { 1118 content::BrowserThread::PostTask( 1119 content::BrowserThread::IO, FROM_HERE, 1120 base::Bind( 1121 &ExtensionRendererState::RemoveWebView, 1122 base::Unretained(ExtensionRendererState::GetInstance()), 1123 web_contents->GetRenderProcessHost()->GetID(), 1124 web_contents->GetRoutingID())); 1125 } 1126 1127 void WebViewGuest::SizeChanged(const gfx::Size& old_size, 1128 const gfx::Size& new_size) { 1129 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 1130 args->SetInteger(webview::kOldHeight, old_size.height()); 1131 args->SetInteger(webview::kOldWidth, old_size.width()); 1132 args->SetInteger(webview::kNewHeight, new_size.height()); 1133 args->SetInteger(webview::kNewWidth, new_size.width()); 1134 DispatchEvent( 1135 new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass())); 1136 } 1137 1138 void WebViewGuest::RequestMediaAccessPermission( 1139 content::WebContents* source, 1140 const content::MediaStreamRequest& request, 1141 const content::MediaResponseCallback& callback) { 1142 base::DictionaryValue request_info; 1143 request_info.Set( 1144 guestview::kUrl, 1145 base::Value::CreateStringValue(request.security_origin.spec())); 1146 RequestPermission(WEB_VIEW_PERMISSION_TYPE_MEDIA, 1147 request_info, 1148 base::Bind(&WebViewGuest::OnWebViewMediaPermissionResponse, 1149 base::Unretained(this), 1150 request, 1151 callback), 1152 false /* allowed_by_default */); 1153 } 1154 1155 void WebViewGuest::CanDownload( 1156 content::RenderViewHost* render_view_host, 1157 const GURL& url, 1158 const std::string& request_method, 1159 const base::Callback<void(bool)>& callback) { 1160 base::DictionaryValue request_info; 1161 request_info.Set( 1162 guestview::kUrl, 1163 base::Value::CreateStringValue(url.spec())); 1164 RequestPermission( 1165 WEB_VIEW_PERMISSION_TYPE_DOWNLOAD, 1166 request_info, 1167 base::Bind(&WebViewGuest::OnWebViewDownloadPermissionResponse, 1168 base::Unretained(this), 1169 callback), 1170 false /* allowed_by_default */); 1171 } 1172 1173 void WebViewGuest::RequestPointerLockPermission( 1174 bool user_gesture, 1175 bool last_unlocked_by_target, 1176 const base::Callback<void(bool)>& callback) { 1177 base::DictionaryValue request_info; 1178 request_info.Set(guestview::kUserGesture, 1179 base::Value::CreateBooleanValue(user_gesture)); 1180 request_info.Set(webview::kLastUnlockedBySelf, 1181 base::Value::CreateBooleanValue(last_unlocked_by_target)); 1182 request_info.Set(guestview::kUrl, 1183 base::Value::CreateStringValue( 1184 guest_web_contents()->GetLastCommittedURL().spec())); 1185 1186 RequestPermission( 1187 WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK, 1188 request_info, 1189 base::Bind(&WebViewGuest::OnWebViewPointerLockPermissionResponse, 1190 base::Unretained(this), 1191 callback), 1192 false /* allowed_by_default */); 1193 } 1194 1195 void WebViewGuest::WillAttachToEmbedder() { 1196 // We must install the mapping from guests to WebViews prior to resuming 1197 // suspended resource loads so that the WebRequest API will catch resource 1198 // requests. 1199 AddWebViewToExtensionRendererState(); 1200 } 1201 1202 content::JavaScriptDialogManager* 1203 WebViewGuest::GetJavaScriptDialogManager() { 1204 return &javascript_dialog_helper_; 1205 } 1206 1207 content::ColorChooser* WebViewGuest::OpenColorChooser( 1208 WebContents* web_contents, 1209 SkColor color, 1210 const std::vector<content::ColorSuggestion>& suggestions) { 1211 if (!attached() || !embedder_web_contents()->GetDelegate()) 1212 return NULL; 1213 return embedder_web_contents()->GetDelegate()->OpenColorChooser( 1214 web_contents, color, suggestions); 1215 } 1216 1217 void WebViewGuest::RunFileChooser(WebContents* web_contents, 1218 const content::FileChooserParams& params) { 1219 if (!attached() || !embedder_web_contents()->GetDelegate()) 1220 return; 1221 1222 embedder_web_contents()->GetDelegate()->RunFileChooser(web_contents, params); 1223 } 1224 1225 void WebViewGuest::NavigateGuest(const std::string& src) { 1226 GURL url = ResolveURL(src); 1227 1228 // Do not allow navigating a guest to schemes other than known safe schemes. 1229 // This will block the embedder trying to load unwanted schemes, e.g. 1230 // chrome://settings. 1231 bool scheme_is_blocked = 1232 (!content::ChildProcessSecurityPolicy::GetInstance()->IsWebSafeScheme( 1233 url.scheme()) && 1234 !url.SchemeIs(url::kAboutScheme)) || 1235 url.SchemeIs(url::kJavaScriptScheme); 1236 if (scheme_is_blocked || !url.is_valid()) { 1237 std::string error_type(net::ErrorToString(net::ERR_ABORTED)); 1238 DCHECK(StartsWithASCII(error_type, "net::", true)); 1239 error_type.erase(0, 5); 1240 LoadAbort(true /* is_top_level */, url, error_type); 1241 return; 1242 } 1243 1244 GURL validated_url(url); 1245 guest_web_contents()->GetRenderProcessHost()-> 1246 FilterURL(false, &validated_url); 1247 // As guests do not swap processes on navigation, only navigations to 1248 // normal web URLs are supported. No protocol handlers are installed for 1249 // other schemes (e.g., WebUI or extensions), and no permissions or bindings 1250 // can be granted to the guest process. 1251 LoadURLWithParams(validated_url, 1252 content::Referrer(), 1253 content::PAGE_TRANSITION_AUTO_TOPLEVEL, 1254 guest_web_contents()); 1255 } 1256 1257 #if defined(OS_CHROMEOS) 1258 void WebViewGuest::OnAccessibilityStatusChanged( 1259 const chromeos::AccessibilityStatusEventDetails& details) { 1260 if (details.notification_type == chromeos::ACCESSIBILITY_MANAGER_SHUTDOWN) { 1261 accessibility_subscription_.reset(); 1262 } else if (details.notification_type == 1263 chromeos::ACCESSIBILITY_TOGGLE_SPOKEN_FEEDBACK) { 1264 if (details.enabled) 1265 InjectChromeVoxIfNeeded(guest_web_contents()->GetRenderViewHost()); 1266 else 1267 chromevox_injected_ = false; 1268 } 1269 } 1270 #endif 1271 1272 void WebViewGuest::InjectChromeVoxIfNeeded( 1273 content::RenderViewHost* render_view_host) { 1274 #if defined(OS_CHROMEOS) 1275 if (!chromevox_injected_) { 1276 chromeos::AccessibilityManager* manager = 1277 chromeos::AccessibilityManager::Get(); 1278 if (manager && manager->IsSpokenFeedbackEnabled()) { 1279 manager->InjectChromeVox(render_view_host); 1280 chromevox_injected_ = true; 1281 } 1282 } 1283 #endif 1284 } 1285 1286 int WebViewGuest::RemoveBridgeID(int bridge_id) { 1287 std::map<int, int>::iterator bridge_itr = 1288 bridge_id_to_request_id_map_.find(bridge_id); 1289 if (bridge_itr == bridge_id_to_request_id_map_.end()) 1290 return webview::kInvalidPermissionRequestID; 1291 1292 int request_id = bridge_itr->second; 1293 bridge_id_to_request_id_map_.erase(bridge_itr); 1294 return request_id; 1295 } 1296 1297 int WebViewGuest::RequestPermission( 1298 WebViewPermissionType permission_type, 1299 const base::DictionaryValue& request_info, 1300 const PermissionResponseCallback& callback, 1301 bool allowed_by_default) { 1302 // If there are too many pending permission requests then reject this request. 1303 if (pending_permission_requests_.size() >= 1304 webview::kMaxOutstandingPermissionRequests) { 1305 // Let the stack unwind before we deny the permission request so that 1306 // objects held by the permission request are not destroyed immediately 1307 // after creation. This is to allow those same objects to be accessed again 1308 // in the same scope without fear of use after freeing. 1309 base::MessageLoop::current()->PostTask( 1310 FROM_HERE, 1311 base::Bind(&PermissionResponseCallback::Run, 1312 base::Owned(new PermissionResponseCallback(callback)), 1313 allowed_by_default, 1314 std::string())); 1315 return webview::kInvalidPermissionRequestID; 1316 } 1317 1318 int request_id = next_permission_request_id_++; 1319 pending_permission_requests_[request_id] = 1320 PermissionResponseInfo(callback, permission_type, allowed_by_default); 1321 scoped_ptr<base::DictionaryValue> args(request_info.DeepCopy()); 1322 args->SetInteger(webview::kRequestId, request_id); 1323 switch (permission_type) { 1324 case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: { 1325 DispatchEvent( 1326 new GuestViewBase::Event(webview::kEventNewWindow, args.Pass())); 1327 break; 1328 } 1329 case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: { 1330 DispatchEvent( 1331 new GuestViewBase::Event(webview::kEventDialog, args.Pass())); 1332 break; 1333 } 1334 default: { 1335 args->SetString(webview::kPermission, 1336 PermissionTypeToString(permission_type)); 1337 DispatchEvent(new GuestViewBase::Event(webview::kEventPermissionRequest, 1338 args.Pass())); 1339 break; 1340 } 1341 } 1342 return request_id; 1343 } 1344 1345 bool WebViewGuest::HandleKeyboardShortcuts( 1346 const content::NativeWebKeyboardEvent& event) { 1347 if (event.type != blink::WebInputEvent::RawKeyDown) 1348 return false; 1349 1350 // If the user hits the escape key without any modifiers then unlock the 1351 // mouse if necessary. 1352 if ((event.windowsKeyCode == ui::VKEY_ESCAPE) && 1353 !(event.modifiers & blink::WebInputEvent::InputModifiers)) { 1354 return guest_web_contents()->GotResponseToLockMouseRequest(false); 1355 } 1356 1357 #if defined(OS_MACOSX) 1358 if (event.modifiers != blink::WebInputEvent::MetaKey) 1359 return false; 1360 1361 if (event.windowsKeyCode == ui::VKEY_OEM_4) { 1362 Go(-1); 1363 return true; 1364 } 1365 1366 if (event.windowsKeyCode == ui::VKEY_OEM_6) { 1367 Go(1); 1368 return true; 1369 } 1370 #else 1371 if (event.windowsKeyCode == ui::VKEY_BROWSER_BACK) { 1372 Go(-1); 1373 return true; 1374 } 1375 1376 if (event.windowsKeyCode == ui::VKEY_BROWSER_FORWARD) { 1377 Go(1); 1378 return true; 1379 } 1380 #endif 1381 1382 return false; 1383 } 1384 1385 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo() 1386 : permission_type(WEB_VIEW_PERMISSION_TYPE_UNKNOWN), 1387 allowed_by_default(false) { 1388 } 1389 1390 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo( 1391 const PermissionResponseCallback& callback, 1392 WebViewPermissionType permission_type, 1393 bool allowed_by_default) 1394 : callback(callback), 1395 permission_type(permission_type), 1396 allowed_by_default(allowed_by_default) { 1397 } 1398 1399 WebViewGuest::PermissionResponseInfo::~PermissionResponseInfo() { 1400 } 1401 1402 void WebViewGuest::ShowContextMenu(int request_id, 1403 const MenuItemVector* items) { 1404 if (!pending_menu_.get()) 1405 return; 1406 1407 // Make sure this was the correct request. 1408 if (request_id != pending_context_menu_request_id_) 1409 return; 1410 1411 // TODO(lazyboy): Implement. 1412 DCHECK(!items); 1413 1414 ContextMenuDelegate* menu_delegate = 1415 ContextMenuDelegate::FromWebContents(guest_web_contents()); 1416 menu_delegate->ShowMenu(pending_menu_.Pass()); 1417 } 1418 1419 void WebViewGuest::SetName(const std::string& name) { 1420 if (name_ == name) 1421 return; 1422 name_ = name; 1423 1424 Send(new ChromeViewMsg_SetName(routing_id(), name_)); 1425 } 1426 1427 void WebViewGuest::SetZoom(double zoom_factor) { 1428 double zoom_level = content::ZoomFactorToZoomLevel(zoom_factor); 1429 content::HostZoomMap::SetZoomLevel(guest_web_contents(), zoom_level); 1430 1431 scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue()); 1432 args->SetDouble(webview::kOldZoomFactor, current_zoom_factor_); 1433 args->SetDouble(webview::kNewZoomFactor, zoom_factor); 1434 DispatchEvent( 1435 new GuestViewBase::Event(webview::kEventZoomChange, args.Pass())); 1436 1437 current_zoom_factor_ = zoom_factor; 1438 } 1439 1440 void WebViewGuest::AddNewContents(content::WebContents* source, 1441 content::WebContents* new_contents, 1442 WindowOpenDisposition disposition, 1443 const gfx::Rect& initial_pos, 1444 bool user_gesture, 1445 bool* was_blocked) { 1446 if (was_blocked) 1447 *was_blocked = false; 1448 RequestNewWindowPermission(disposition, 1449 initial_pos, 1450 user_gesture, 1451 new_contents); 1452 } 1453 1454 content::WebContents* WebViewGuest::OpenURLFromTab( 1455 content::WebContents* source, 1456 const content::OpenURLParams& params) { 1457 // If the guest wishes to navigate away prior to attachment then we save the 1458 // navigation to perform upon attachment. Navigation initializes a lot of 1459 // state that assumes an embedder exists, such as RenderWidgetHostViewGuest. 1460 // Navigation also resumes resource loading which we don't want to allow 1461 // until attachment. 1462 if (!attached()) { 1463 WebViewGuest* opener = GetOpener(); 1464 PendingWindowMap::iterator it = 1465 opener->pending_new_windows_.find(this); 1466 if (it == opener->pending_new_windows_.end()) 1467 return NULL; 1468 const NewWindowInfo& info = it->second; 1469 NewWindowInfo new_window_info(params.url, info.name); 1470 new_window_info.changed = new_window_info.url != info.url; 1471 it->second = new_window_info; 1472 return NULL; 1473 } 1474 if (params.disposition == CURRENT_TAB) { 1475 // This can happen for cross-site redirects. 1476 LoadURLWithParams(params.url, params.referrer, params.transition, source); 1477 return source; 1478 } 1479 1480 return CreateNewGuestWindow(params)->guest_web_contents(); 1481 } 1482 1483 void WebViewGuest::WebContentsCreated(WebContents* source_contents, 1484 int opener_render_frame_id, 1485 const base::string16& frame_name, 1486 const GURL& target_url, 1487 content::WebContents* new_contents) { 1488 WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents); 1489 CHECK(guest); 1490 guest->SetOpener(this); 1491 std::string guest_name = base::UTF16ToUTF8(frame_name); 1492 guest->name_ = guest_name; 1493 pending_new_windows_.insert( 1494 std::make_pair(guest, NewWindowInfo(target_url, guest_name))); 1495 } 1496 1497 void WebViewGuest::LoadURLWithParams(const GURL& url, 1498 const content::Referrer& referrer, 1499 content::PageTransition transition_type, 1500 content::WebContents* web_contents) { 1501 content::NavigationController::LoadURLParams load_url_params(url); 1502 load_url_params.referrer = referrer; 1503 load_url_params.transition_type = transition_type; 1504 load_url_params.extra_headers = std::string(); 1505 if (is_overriding_user_agent_) { 1506 load_url_params.override_user_agent = 1507 content::NavigationController::UA_OVERRIDE_TRUE; 1508 } 1509 web_contents->GetController().LoadURLWithParams(load_url_params); 1510 } 1511 1512 void WebViewGuest::RequestNewWindowPermission( 1513 WindowOpenDisposition disposition, 1514 const gfx::Rect& initial_bounds, 1515 bool user_gesture, 1516 content::WebContents* new_contents) { 1517 WebViewGuest* guest = WebViewGuest::FromWebContents(new_contents); 1518 if (!guest) 1519 return; 1520 PendingWindowMap::iterator it = pending_new_windows_.find(guest); 1521 if (it == pending_new_windows_.end()) 1522 return; 1523 const NewWindowInfo& new_window_info = it->second; 1524 1525 // Retrieve the opener partition info if we have it. 1526 const GURL& site_url = new_contents->GetSiteInstance()->GetSiteURL(); 1527 std::string storage_partition_id = GetStoragePartitionIdFromSiteURL(site_url); 1528 1529 base::DictionaryValue request_info; 1530 request_info.Set(webview::kInitialHeight, 1531 base::Value::CreateIntegerValue(initial_bounds.height())); 1532 request_info.Set(webview::kInitialWidth, 1533 base::Value::CreateIntegerValue(initial_bounds.width())); 1534 request_info.Set(webview::kTargetURL, 1535 base::Value::CreateStringValue(new_window_info.url.spec())); 1536 request_info.Set(webview::kName, 1537 base::Value::CreateStringValue(new_window_info.name)); 1538 request_info.Set(webview::kWindowID, 1539 base::Value::CreateIntegerValue(guest->guest_instance_id())); 1540 // We pass in partition info so that window-s created through newwindow 1541 // API can use it to set their partition attribute. 1542 request_info.Set(webview::kStoragePartitionId, 1543 base::Value::CreateStringValue(storage_partition_id)); 1544 request_info.Set(webview::kWindowOpenDisposition, 1545 base::Value::CreateStringValue( 1546 WindowOpenDispositionToString(disposition))); 1547 1548 RequestPermission(WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW, 1549 request_info, 1550 base::Bind(&WebViewGuest::OnWebViewNewWindowResponse, 1551 base::Unretained(this), 1552 guest->guest_instance_id()), 1553 false /* allowed_by_default */); 1554 } 1555 1556 void WebViewGuest::DestroyUnattachedWindows() { 1557 // Destroy() reaches in and removes the WebViewGuest from its opener's 1558 // pending_new_windows_ set. To avoid mutating the set while iterating, we 1559 // create a copy of the pending new windows set and iterate over the copy. 1560 PendingWindowMap pending_new_windows(pending_new_windows_); 1561 // Clean up unattached new windows opened by this guest. 1562 for (PendingWindowMap::const_iterator it = pending_new_windows.begin(); 1563 it != pending_new_windows.end(); ++it) { 1564 it->first->Destroy(); 1565 } 1566 // All pending windows should be removed from the set after Destroy() is 1567 // called on all of them. 1568 DCHECK(pending_new_windows_.empty()); 1569 } 1570 1571 GURL WebViewGuest::ResolveURL(const std::string& src) { 1572 if (!in_extension()) { 1573 NOTREACHED(); 1574 return GURL(src); 1575 } 1576 1577 GURL default_url(base::StringPrintf("%s://%s/", 1578 extensions::kExtensionScheme, 1579 embedder_extension_id().c_str())); 1580 return default_url.Resolve(src); 1581 } 1582 1583 void WebViewGuest::OnWebViewNewWindowResponse( 1584 int new_window_instance_id, 1585 bool allow, 1586 const std::string& user_input) { 1587 WebViewGuest* guest = 1588 WebViewGuest::From(embedder_render_process_id(), new_window_instance_id); 1589 if (!guest) 1590 return; 1591 1592 if (!allow) 1593 guest->Destroy(); 1594 } 1595