interstitial_page_impl.cc revision 0529e5d033099cbfc42635f6f6183833b09dff6e
1// Copyright 2013 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 "content/browser/frame_host/interstitial_page_impl.h" 6 7#include <vector> 8 9#include "base/bind.h" 10#include "base/compiler_specific.h" 11#include "base/message_loop/message_loop.h" 12#include "base/strings/string_util.h" 13#include "base/strings/utf_string_conversions.h" 14#include "base/threading/thread.h" 15#include "content/browser/dom_storage/dom_storage_context_wrapper.h" 16#include "content/browser/dom_storage/session_storage_namespace_impl.h" 17#include "content/browser/frame_host/interstitial_page_navigator_impl.h" 18#include "content/browser/frame_host/navigation_controller_impl.h" 19#include "content/browser/frame_host/navigation_entry_impl.h" 20#include "content/browser/loader/resource_dispatcher_host_impl.h" 21#include "content/browser/renderer_host/render_process_host_impl.h" 22#include "content/browser/renderer_host/render_view_host_factory.h" 23#include "content/browser/renderer_host/render_view_host_impl.h" 24#include "content/browser/site_instance_impl.h" 25#include "content/browser/web_contents/web_contents_impl.h" 26#include "content/common/frame_messages.h" 27#include "content/common/view_messages.h" 28#include "content/port/browser/render_view_host_delegate_view.h" 29#include "content/port/browser/render_widget_host_view_port.h" 30#include "content/port/browser/web_contents_view_port.h" 31#include "content/public/browser/browser_context.h" 32#include "content/public/browser/browser_thread.h" 33#include "content/public/browser/content_browser_client.h" 34#include "content/public/browser/dom_operation_notification_details.h" 35#include "content/public/browser/interstitial_page_delegate.h" 36#include "content/public/browser/invalidate_type.h" 37#include "content/public/browser/notification_service.h" 38#include "content/public/browser/notification_source.h" 39#include "content/public/browser/storage_partition.h" 40#include "content/public/browser/user_metrics.h" 41#include "content/public/browser/web_contents_delegate.h" 42#include "content/public/common/bindings_policy.h" 43#include "content/public/common/page_transition_types.h" 44#include "net/base/escape.h" 45#include "net/url_request/url_request_context_getter.h" 46 47using blink::WebDragOperation; 48using blink::WebDragOperationsMask; 49 50namespace content { 51namespace { 52 53void ResourceRequestHelper(ResourceDispatcherHostImpl* rdh, 54 int process_id, 55 int render_view_host_id, 56 ResourceRequestAction action) { 57 switch (action) { 58 case BLOCK: 59 rdh->BlockRequestsForRoute(process_id, render_view_host_id); 60 break; 61 case RESUME: 62 rdh->ResumeBlockedRequestsForRoute(process_id, render_view_host_id); 63 break; 64 case CANCEL: 65 rdh->CancelBlockedRequestsForRoute(process_id, render_view_host_id); 66 break; 67 default: 68 NOTREACHED(); 69 } 70} 71 72} // namespace 73 74class InterstitialPageImpl::InterstitialPageRVHDelegateView 75 : public RenderViewHostDelegateView { 76 public: 77 explicit InterstitialPageRVHDelegateView(InterstitialPageImpl* page); 78 79 // RenderViewHostDelegateView implementation: 80#if defined(OS_MACOSX) || defined(OS_ANDROID) 81 virtual void ShowPopupMenu(const gfx::Rect& bounds, 82 int item_height, 83 double item_font_size, 84 int selected_item, 85 const std::vector<MenuItem>& items, 86 bool right_aligned, 87 bool allow_multiple_selection) OVERRIDE; 88 virtual void HidePopupMenu() OVERRIDE; 89#endif 90 virtual void StartDragging(const DropData& drop_data, 91 WebDragOperationsMask operations_allowed, 92 const gfx::ImageSkia& image, 93 const gfx::Vector2d& image_offset, 94 const DragEventSourceInfo& event_info) OVERRIDE; 95 virtual void UpdateDragCursor(WebDragOperation operation) OVERRIDE; 96 virtual void GotFocus() OVERRIDE; 97 virtual void TakeFocus(bool reverse) OVERRIDE; 98 virtual void OnFindReply(int request_id, 99 int number_of_matches, 100 const gfx::Rect& selection_rect, 101 int active_match_ordinal, 102 bool final_update); 103 104 private: 105 InterstitialPageImpl* interstitial_page_; 106 107 DISALLOW_COPY_AND_ASSIGN(InterstitialPageRVHDelegateView); 108}; 109 110 111// We keep a map of the various blocking pages shown as the UI tests need to 112// be able to retrieve them. 113typedef std::map<WebContents*, InterstitialPageImpl*> InterstitialPageMap; 114static InterstitialPageMap* g_web_contents_to_interstitial_page; 115 116// Initializes g_web_contents_to_interstitial_page in a thread-safe manner. 117// Should be called before accessing g_web_contents_to_interstitial_page. 118static void InitInterstitialPageMap() { 119 if (!g_web_contents_to_interstitial_page) 120 g_web_contents_to_interstitial_page = new InterstitialPageMap; 121} 122 123InterstitialPage* InterstitialPage::Create(WebContents* web_contents, 124 bool new_navigation, 125 const GURL& url, 126 InterstitialPageDelegate* delegate) { 127 return new InterstitialPageImpl( 128 web_contents, 129 static_cast<RenderWidgetHostDelegate*>( 130 static_cast<WebContentsImpl*>(web_contents)), 131 new_navigation, url, delegate); 132} 133 134InterstitialPage* InterstitialPage::GetInterstitialPage( 135 WebContents* web_contents) { 136 InitInterstitialPageMap(); 137 InterstitialPageMap::const_iterator iter = 138 g_web_contents_to_interstitial_page->find(web_contents); 139 if (iter == g_web_contents_to_interstitial_page->end()) 140 return NULL; 141 142 return iter->second; 143} 144 145InterstitialPageImpl::InterstitialPageImpl( 146 WebContents* web_contents, 147 RenderWidgetHostDelegate* render_widget_host_delegate, 148 bool new_navigation, 149 const GURL& url, 150 InterstitialPageDelegate* delegate) 151 : WebContentsObserver(web_contents), 152 web_contents_(web_contents), 153 controller_(static_cast<NavigationControllerImpl*>( 154 &web_contents->GetController())), 155 render_widget_host_delegate_(render_widget_host_delegate), 156 url_(url), 157 new_navigation_(new_navigation), 158 should_discard_pending_nav_entry_(new_navigation), 159 reload_on_dont_proceed_(false), 160 enabled_(true), 161 action_taken_(NO_ACTION), 162 render_view_host_(NULL), 163 // TODO(nasko): The InterstitialPageImpl will need to provide its own 164 // NavigationControllerImpl to the Navigator, which is separate from 165 // the WebContents one, so we can enforce no navigation policy here. 166 // While we get the code to a point to do this, pass NULL for it. 167 // TODO(creis): We will also need to pass delegates for the RVHM as we 168 // start to use it. 169 frame_tree_(new InterstitialPageNavigatorImpl(this, controller_), 170 this, this, this, 171 static_cast<WebContentsImpl*>(web_contents)), 172 original_child_id_(web_contents->GetRenderProcessHost()->GetID()), 173 original_rvh_id_(web_contents->GetRenderViewHost()->GetRoutingID()), 174 should_revert_web_contents_title_(false), 175 web_contents_was_loading_(false), 176 resource_dispatcher_host_notified_(false), 177 rvh_delegate_view_(new InterstitialPageRVHDelegateView(this)), 178 create_view_(true), 179 delegate_(delegate), 180 weak_ptr_factory_(this) { 181 InitInterstitialPageMap(); 182 // It would be inconsistent to create an interstitial with no new navigation 183 // (which is the case when the interstitial was triggered by a sub-resource on 184 // a page) when we have a pending entry (in the process of loading a new top 185 // frame). 186 DCHECK(new_navigation || !web_contents->GetController().GetPendingEntry()); 187} 188 189InterstitialPageImpl::~InterstitialPageImpl() { 190} 191 192void InterstitialPageImpl::Show() { 193 if (!enabled()) 194 return; 195 196 // If an interstitial is already showing or about to be shown, close it before 197 // showing the new one. 198 // Be careful not to take an action on the old interstitial more than once. 199 InterstitialPageMap::const_iterator iter = 200 g_web_contents_to_interstitial_page->find(web_contents_); 201 if (iter != g_web_contents_to_interstitial_page->end()) { 202 InterstitialPageImpl* interstitial = iter->second; 203 if (interstitial->action_taken_ != NO_ACTION) { 204 interstitial->Hide(); 205 } else { 206 // If we are currently showing an interstitial page for which we created 207 // a transient entry and a new interstitial is shown as the result of a 208 // new browser initiated navigation, then that transient entry has already 209 // been discarded and a new pending navigation entry created. 210 // So we should not discard that new pending navigation entry. 211 // See http://crbug.com/9791 212 if (new_navigation_ && interstitial->new_navigation_) 213 interstitial->should_discard_pending_nav_entry_= false; 214 interstitial->DontProceed(); 215 } 216 } 217 218 // Block the resource requests for the render view host while it is hidden. 219 TakeActionOnResourceDispatcher(BLOCK); 220 // We need to be notified when the RenderViewHost is destroyed so we can 221 // cancel the blocked requests. We cannot do that on 222 // NOTIFY_WEB_CONTENTS_DESTROYED as at that point the RenderViewHost has 223 // already been destroyed. 224 notification_registrar_.Add( 225 this, NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED, 226 Source<RenderWidgetHost>(controller_->delegate()->GetRenderViewHost())); 227 228 // Update the g_web_contents_to_interstitial_page map. 229 iter = g_web_contents_to_interstitial_page->find(web_contents_); 230 DCHECK(iter == g_web_contents_to_interstitial_page->end()); 231 (*g_web_contents_to_interstitial_page)[web_contents_] = this; 232 233 if (new_navigation_) { 234 NavigationEntryImpl* entry = new NavigationEntryImpl; 235 entry->SetURL(url_); 236 entry->SetVirtualURL(url_); 237 entry->set_page_type(PAGE_TYPE_INTERSTITIAL); 238 239 // Give delegates a chance to set some states on the navigation entry. 240 delegate_->OverrideEntry(entry); 241 242 controller_->SetTransientEntry(entry); 243 } 244 245 DCHECK(!render_view_host_); 246 render_view_host_ = static_cast<RenderViewHostImpl*>(CreateRenderViewHost()); 247 render_view_host_->AttachToFrameTree(); 248 CreateWebContentsView(); 249 250 std::string data_url = "data:text/html;charset=utf-8," + 251 net::EscapePath(delegate_->GetHTMLContents()); 252 render_view_host_->NavigateToURL(GURL(data_url)); 253 254 notification_registrar_.Add(this, NOTIFICATION_NAV_ENTRY_PENDING, 255 Source<NavigationController>(controller_)); 256} 257 258void InterstitialPageImpl::Hide() { 259 // We may have already been hidden, and are just waiting to be deleted. 260 // We can't check for enabled() here, because some callers have already 261 // called Disable. 262 if (!render_view_host_) 263 return; 264 265 Disable(); 266 267 RenderWidgetHostView* old_view = 268 controller_->delegate()->GetRenderViewHost()->GetView(); 269 if (controller_->delegate()->GetInterstitialPage() == this && 270 old_view && 271 !old_view->IsShowing() && 272 !controller_->delegate()->IsHidden()) { 273 // Show the original RVH since we're going away. Note it might not exist if 274 // the renderer crashed while the interstitial was showing. 275 // Note that it is important that we don't call Show() if the view is 276 // already showing. That would result in bad things (unparented HWND on 277 // Windows for example) happening. 278 old_view->Show(); 279 } 280 281 // If the focus was on the interstitial, let's keep it to the page. 282 // (Note that in unit-tests the RVH may not have a view). 283 if (render_view_host_->GetView() && 284 render_view_host_->GetView()->HasFocus() && 285 controller_->delegate()->GetRenderViewHost()->GetView()) { 286 RenderWidgetHostViewPort::FromRWHV( 287 controller_->delegate()->GetRenderViewHost()->GetView())->Focus(); 288 } 289 290 // Delete this and call Shutdown on the RVH asynchronously, as we may have 291 // been called from a RVH delegate method, and we can't delete the RVH out 292 // from under itself. 293 base::MessageLoop::current()->PostNonNestableTask( 294 FROM_HERE, 295 base::Bind(&InterstitialPageImpl::Shutdown, 296 weak_ptr_factory_.GetWeakPtr())); 297 render_view_host_ = NULL; 298 frame_tree_.ResetForMainFrameSwap(); 299 controller_->delegate()->DetachInterstitialPage(); 300 // Let's revert to the original title if necessary. 301 NavigationEntry* entry = controller_->GetVisibleEntry(); 302 if (!new_navigation_ && should_revert_web_contents_title_) { 303 entry->SetTitle(original_web_contents_title_); 304 controller_->delegate()->NotifyNavigationStateChanged( 305 INVALIDATE_TYPE_TITLE); 306 } 307 308 InterstitialPageMap::iterator iter = 309 g_web_contents_to_interstitial_page->find(web_contents_); 310 DCHECK(iter != g_web_contents_to_interstitial_page->end()); 311 if (iter != g_web_contents_to_interstitial_page->end()) 312 g_web_contents_to_interstitial_page->erase(iter); 313 314 // Clear the WebContents pointer, because it may now be deleted. 315 // This signifies that we are in the process of shutting down. 316 web_contents_ = NULL; 317} 318 319void InterstitialPageImpl::Observe( 320 int type, 321 const NotificationSource& source, 322 const NotificationDetails& details) { 323 switch (type) { 324 case NOTIFICATION_NAV_ENTRY_PENDING: 325 // We are navigating away from the interstitial (the user has typed a URL 326 // in the location bar or clicked a bookmark). Make sure clicking on the 327 // interstitial will have no effect. Also cancel any blocked requests 328 // on the ResourceDispatcherHost. Note that when we get this notification 329 // the RenderViewHost has not yet navigated so we'll unblock the 330 // RenderViewHost before the resource request for the new page we are 331 // navigating arrives in the ResourceDispatcherHost. This ensures that 332 // request won't be blocked if the same RenderViewHost was used for the 333 // new navigation. 334 Disable(); 335 TakeActionOnResourceDispatcher(CANCEL); 336 break; 337 case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: 338 if (action_taken_ == NO_ACTION) { 339 // The RenderViewHost is being destroyed (as part of the tab being 340 // closed); make sure we clear the blocked requests. 341 RenderViewHost* rvh = static_cast<RenderViewHost*>( 342 static_cast<RenderViewHostImpl*>( 343 RenderWidgetHostImpl::From( 344 Source<RenderWidgetHost>(source).ptr()))); 345 DCHECK(rvh->GetProcess()->GetID() == original_child_id_ && 346 rvh->GetRoutingID() == original_rvh_id_); 347 TakeActionOnResourceDispatcher(CANCEL); 348 } 349 break; 350 default: 351 NOTREACHED(); 352 } 353} 354 355void InterstitialPageImpl::NavigationEntryCommitted( 356 const LoadCommittedDetails& load_details) { 357 OnNavigatingAwayOrTabClosing(); 358} 359 360void InterstitialPageImpl::WebContentsDestroyed(WebContents* web_contents) { 361 OnNavigatingAwayOrTabClosing(); 362} 363 364bool InterstitialPageImpl::OnMessageReceived(RenderFrameHost* render_frame_host, 365 const IPC::Message& message) { 366 return OnMessageReceived(message); 367} 368 369bool InterstitialPageImpl::OnMessageReceived(RenderViewHost* render_view_host, 370 const IPC::Message& message) { 371 return OnMessageReceived(message); 372} 373 374bool InterstitialPageImpl::OnMessageReceived(const IPC::Message& message) { 375 376 bool handled = true; 377 bool message_is_ok = true; 378 IPC_BEGIN_MESSAGE_MAP_EX(InterstitialPageImpl, message, message_is_ok) 379 IPC_MESSAGE_HANDLER(FrameHostMsg_DomOperationResponse, 380 OnDomOperationResponse) 381 IPC_MESSAGE_UNHANDLED(handled = false) 382 IPC_END_MESSAGE_MAP_EX() 383 384 if (!message_is_ok) { 385 RecordAction(base::UserMetricsAction("BadMessageTerminate_RVD")); 386 web_contents()->GetRenderProcessHost()->ReceivedBadMessage(); 387 } 388 389 return handled; 390} 391 392void InterstitialPageImpl::RenderFrameCreated( 393 RenderFrameHost* render_frame_host) { 394 // Note this is only for subframes in the interstitial, the notification for 395 // the main frame happens in RenderViewCreated. 396 controller_->delegate()->RenderFrameForInterstitialPageCreated( 397 render_frame_host); 398} 399 400RenderViewHostDelegateView* InterstitialPageImpl::GetDelegateView() { 401 return rvh_delegate_view_.get(); 402} 403 404const GURL& InterstitialPageImpl::GetMainFrameLastCommittedURL() const { 405 return url_; 406} 407 408void InterstitialPageImpl::RenderViewTerminated( 409 RenderViewHost* render_view_host, 410 base::TerminationStatus status, 411 int error_code) { 412 // Our renderer died. This should not happen in normal cases. 413 // If we haven't already started shutdown, just dismiss the interstitial. 414 // We cannot check for enabled() here, because we may have called Disable 415 // without calling Hide. 416 if (render_view_host_) 417 DontProceed(); 418} 419 420void InterstitialPageImpl::DidNavigate( 421 RenderViewHost* render_view_host, 422 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) { 423 // A fast user could have navigated away from the page that triggered the 424 // interstitial while the interstitial was loading, that would have disabled 425 // us. In that case we can dismiss ourselves. 426 if (!enabled()) { 427 DontProceed(); 428 return; 429 } 430 if (PageTransitionCoreTypeIs(params.transition, 431 PAGE_TRANSITION_AUTO_SUBFRAME)) { 432 // No need to handle navigate message from iframe in the interstitial page. 433 return; 434 } 435 436 // The RenderViewHost has loaded its contents, we can show it now. 437 if (!controller_->delegate()->IsHidden()) 438 render_view_host_->GetView()->Show(); 439 controller_->delegate()->AttachInterstitialPage(this); 440 441 RenderWidgetHostView* rwh_view = 442 controller_->delegate()->GetRenderViewHost()->GetView(); 443 444 // The RenderViewHost may already have crashed before we even get here. 445 if (rwh_view) { 446 // If the page has focus, focus the interstitial. 447 if (rwh_view->HasFocus()) 448 Focus(); 449 450 // Hide the original RVH since we're showing the interstitial instead. 451 rwh_view->Hide(); 452 } 453 454 // Notify the tab we are not loading so the throbber is stopped. It also 455 // causes a WebContentsObserver::DidStopLoading callback that the 456 // AutomationProvider (used by the UI tests) expects to consider a navigation 457 // as complete. Without this, navigating in a UI test to a URL that triggers 458 // an interstitial would hang. 459 web_contents_was_loading_ = controller_->delegate()->IsLoading(); 460 controller_->delegate()->SetIsLoading( 461 controller_->delegate()->GetRenderViewHost(), false, true, NULL); 462} 463 464void InterstitialPageImpl::UpdateTitle( 465 RenderViewHost* render_view_host, 466 int32 page_id, 467 const base::string16& title, 468 base::i18n::TextDirection title_direction) { 469 if (!enabled()) 470 return; 471 472 DCHECK(render_view_host == render_view_host_); 473 NavigationEntry* entry = controller_->GetVisibleEntry(); 474 if (!entry) { 475 // Crash reports from the field indicate this can be NULL. 476 // This is unexpected as InterstitialPages constructed with the 477 // new_navigation flag set to true create a transient navigation entry 478 // (that is returned as the active entry). And the only case so far of 479 // interstitial created with that flag set to false is with the 480 // SafeBrowsingBlockingPage, when the resource triggering the interstitial 481 // is a sub-resource, meaning the main page has already been loaded and a 482 // navigation entry should have been created. 483 NOTREACHED(); 484 return; 485 } 486 487 // If this interstitial is shown on an existing navigation entry, we'll need 488 // to remember its title so we can revert to it when hidden. 489 if (!new_navigation_ && !should_revert_web_contents_title_) { 490 original_web_contents_title_ = entry->GetTitle(); 491 should_revert_web_contents_title_ = true; 492 } 493 // TODO(evan): make use of title_direction. 494 // http://code.google.com/p/chromium/issues/detail?id=27094 495 entry->SetTitle(title); 496 controller_->delegate()->NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE); 497} 498 499RendererPreferences InterstitialPageImpl::GetRendererPrefs( 500 BrowserContext* browser_context) const { 501 delegate_->OverrideRendererPrefs(&renderer_preferences_); 502 return renderer_preferences_; 503} 504 505WebPreferences InterstitialPageImpl::GetWebkitPrefs() { 506 if (!enabled()) 507 return WebPreferences(); 508 509 return render_view_host_->GetWebkitPrefs(url_); 510} 511 512void InterstitialPageImpl::RenderWidgetDeleted( 513 RenderWidgetHostImpl* render_widget_host) { 514 // TODO(creis): Remove this method once we verify the shutdown path is sane. 515 CHECK(!web_contents_); 516} 517 518bool InterstitialPageImpl::PreHandleKeyboardEvent( 519 const NativeWebKeyboardEvent& event, 520 bool* is_keyboard_shortcut) { 521 if (!enabled()) 522 return false; 523 return render_widget_host_delegate_->PreHandleKeyboardEvent( 524 event, is_keyboard_shortcut); 525} 526 527void InterstitialPageImpl::HandleKeyboardEvent( 528 const NativeWebKeyboardEvent& event) { 529 if (enabled()) 530 render_widget_host_delegate_->HandleKeyboardEvent(event); 531} 532 533#if defined(OS_WIN) 534gfx::NativeViewAccessible 535InterstitialPageImpl::GetParentNativeViewAccessible() { 536 return render_widget_host_delegate_->GetParentNativeViewAccessible(); 537} 538#endif 539 540WebContents* InterstitialPageImpl::web_contents() const { 541 return web_contents_; 542} 543 544RenderViewHost* InterstitialPageImpl::CreateRenderViewHost() { 545 if (!enabled()) 546 return NULL; 547 548 // Interstitial pages don't want to share the session storage so we mint a 549 // new one. 550 BrowserContext* browser_context = web_contents()->GetBrowserContext(); 551 scoped_refptr<SiteInstance> site_instance = 552 SiteInstance::Create(browser_context); 553 DOMStorageContextWrapper* dom_storage_context = 554 static_cast<DOMStorageContextWrapper*>( 555 BrowserContext::GetStoragePartition( 556 browser_context, site_instance.get())->GetDOMStorageContext()); 557 session_storage_namespace_ = 558 new SessionStorageNamespaceImpl(dom_storage_context); 559 560 // Use the RenderViewHost from our FrameTree. 561 frame_tree_.root()->render_manager()->Init( 562 browser_context, site_instance.get(), MSG_ROUTING_NONE, MSG_ROUTING_NONE); 563 return frame_tree_.root()->current_frame_host()->render_view_host(); 564} 565 566WebContentsView* InterstitialPageImpl::CreateWebContentsView() { 567 if (!enabled() || !create_view_) 568 return NULL; 569 WebContentsView* web_contents_view = web_contents()->GetView(); 570 WebContentsViewPort* web_contents_view_port = 571 static_cast<WebContentsViewPort*>(web_contents_view); 572 RenderWidgetHostView* view = 573 web_contents_view_port->CreateViewForWidget(render_view_host_); 574 render_view_host_->SetView(view); 575 render_view_host_->AllowBindings(BINDINGS_POLICY_DOM_AUTOMATION); 576 577 int32 max_page_id = web_contents()-> 578 GetMaxPageIDForSiteInstance(render_view_host_->GetSiteInstance()); 579 render_view_host_->CreateRenderView(base::string16(), 580 MSG_ROUTING_NONE, 581 max_page_id, 582 false); 583 controller_->delegate()->RenderFrameForInterstitialPageCreated( 584 frame_tree_.root()->current_frame_host()); 585 view->SetSize(web_contents_view->GetContainerSize()); 586 // Don't show the interstitial until we have navigated to it. 587 view->Hide(); 588 return web_contents_view; 589} 590 591void InterstitialPageImpl::Proceed() { 592 // Don't repeat this if we are already shutting down. We cannot check for 593 // enabled() here, because we may have called Disable without calling Hide. 594 if (!render_view_host_) 595 return; 596 597 if (action_taken_ != NO_ACTION) { 598 NOTREACHED(); 599 return; 600 } 601 Disable(); 602 action_taken_ = PROCEED_ACTION; 603 604 // Resumes the throbber, if applicable. 605 if (web_contents_was_loading_) 606 controller_->delegate()->SetIsLoading( 607 controller_->delegate()->GetRenderViewHost(), true, true, NULL); 608 609 // If this is a new navigation, the old page is going away, so we cancel any 610 // blocked requests for it. If it is not a new navigation, then it means the 611 // interstitial was shown as a result of a resource loading in the page. 612 // Since the user wants to proceed, we'll let any blocked request go through. 613 if (new_navigation_) 614 TakeActionOnResourceDispatcher(CANCEL); 615 else 616 TakeActionOnResourceDispatcher(RESUME); 617 618 // No need to hide if we are a new navigation, we'll get hidden when the 619 // navigation is committed. 620 if (!new_navigation_) { 621 Hide(); 622 delegate_->OnProceed(); 623 return; 624 } 625 626 delegate_->OnProceed(); 627} 628 629void InterstitialPageImpl::DontProceed() { 630 // Don't repeat this if we are already shutting down. We cannot check for 631 // enabled() here, because we may have called Disable without calling Hide. 632 if (!render_view_host_) 633 return; 634 DCHECK(action_taken_ != DONT_PROCEED_ACTION); 635 636 Disable(); 637 action_taken_ = DONT_PROCEED_ACTION; 638 639 // If this is a new navigation, we are returning to the original page, so we 640 // resume blocked requests for it. If it is not a new navigation, then it 641 // means the interstitial was shown as a result of a resource loading in the 642 // page and we won't return to the original page, so we cancel blocked 643 // requests in that case. 644 if (new_navigation_) 645 TakeActionOnResourceDispatcher(RESUME); 646 else 647 TakeActionOnResourceDispatcher(CANCEL); 648 649 if (should_discard_pending_nav_entry_) { 650 // Since no navigation happens we have to discard the transient entry 651 // explicitely. Note that by calling DiscardNonCommittedEntries() we also 652 // discard the pending entry, which is what we want, since the navigation is 653 // cancelled. 654 controller_->DiscardNonCommittedEntries(); 655 } 656 657 if (reload_on_dont_proceed_) 658 controller_->Reload(true); 659 660 Hide(); 661 delegate_->OnDontProceed(); 662} 663 664void InterstitialPageImpl::CancelForNavigation() { 665 // The user is trying to navigate away. We should unblock the renderer and 666 // disable the interstitial, but keep it visible until the navigation 667 // completes. 668 Disable(); 669 // If this interstitial was shown for a new navigation, allow any navigations 670 // on the original page to resume (e.g., subresource requests, XHRs, etc). 671 // Otherwise, cancel the pending, possibly dangerous navigations. 672 if (new_navigation_) 673 TakeActionOnResourceDispatcher(RESUME); 674 else 675 TakeActionOnResourceDispatcher(CANCEL); 676} 677 678void InterstitialPageImpl::SetSize(const gfx::Size& size) { 679 if (!enabled()) 680 return; 681#if !defined(OS_MACOSX) 682 // When a tab is closed, we might be resized after our view was NULLed 683 // (typically if there was an info-bar). 684 if (render_view_host_->GetView()) 685 render_view_host_->GetView()->SetSize(size); 686#else 687 // TODO(port): Does Mac need to SetSize? 688 NOTIMPLEMENTED(); 689#endif 690} 691 692void InterstitialPageImpl::Focus() { 693 // Focus the native window. 694 if (!enabled()) 695 return; 696 RenderWidgetHostViewPort::FromRWHV(render_view_host_->GetView())->Focus(); 697} 698 699void InterstitialPageImpl::FocusThroughTabTraversal(bool reverse) { 700 if (!enabled()) 701 return; 702 render_view_host_->SetInitialFocus(reverse); 703} 704 705RenderWidgetHostView* InterstitialPageImpl::GetView() { 706 return render_view_host_->GetView(); 707} 708 709RenderViewHost* InterstitialPageImpl::GetRenderViewHostForTesting() const { 710 return render_view_host_; 711} 712 713#if defined(OS_ANDROID) 714RenderViewHost* InterstitialPageImpl::GetRenderViewHost() const { 715 return render_view_host_; 716} 717#endif 718 719InterstitialPageDelegate* InterstitialPageImpl::GetDelegateForTesting() { 720 return delegate_.get(); 721} 722 723void InterstitialPageImpl::DontCreateViewForTesting() { 724 create_view_ = false; 725} 726 727gfx::Rect InterstitialPageImpl::GetRootWindowResizerRect() const { 728 return gfx::Rect(); 729} 730 731void InterstitialPageImpl::CreateNewWindow( 732 int render_process_id, 733 int route_id, 734 int main_frame_route_id, 735 const ViewHostMsg_CreateWindow_Params& params, 736 SessionStorageNamespace* session_storage_namespace) { 737 NOTREACHED() << "InterstitialPage does not support showing popups yet."; 738} 739 740void InterstitialPageImpl::CreateNewWidget(int render_process_id, 741 int route_id, 742 blink::WebPopupType popup_type) { 743 NOTREACHED() << "InterstitialPage does not support showing drop-downs yet."; 744} 745 746void InterstitialPageImpl::CreateNewFullscreenWidget(int render_process_id, 747 int route_id) { 748 NOTREACHED() 749 << "InterstitialPage does not support showing full screen popups."; 750} 751 752void InterstitialPageImpl::ShowCreatedWindow(int route_id, 753 WindowOpenDisposition disposition, 754 const gfx::Rect& initial_pos, 755 bool user_gesture) { 756 NOTREACHED() << "InterstitialPage does not support showing popups yet."; 757} 758 759void InterstitialPageImpl::ShowCreatedWidget(int route_id, 760 const gfx::Rect& initial_pos) { 761 NOTREACHED() << "InterstitialPage does not support showing drop-downs yet."; 762} 763 764void InterstitialPageImpl::ShowCreatedFullscreenWidget(int route_id) { 765 NOTREACHED() 766 << "InterstitialPage does not support showing full screen popups."; 767} 768 769SessionStorageNamespace* InterstitialPageImpl::GetSessionStorageNamespace( 770 SiteInstance* instance) { 771 return session_storage_namespace_.get(); 772} 773 774FrameTree* InterstitialPageImpl::GetFrameTree() { 775 return &frame_tree_; 776} 777 778void InterstitialPageImpl::Disable() { 779 enabled_ = false; 780} 781 782void InterstitialPageImpl::Shutdown() { 783 delete this; 784} 785 786void InterstitialPageImpl::OnNavigatingAwayOrTabClosing() { 787 if (action_taken_ == NO_ACTION) { 788 // We are navigating away from the interstitial or closing a tab with an 789 // interstitial. Default to DontProceed(). We don't just call Hide as 790 // subclasses will almost certainly override DontProceed to do some work 791 // (ex: close pending connections). 792 DontProceed(); 793 } else { 794 // User decided to proceed and either the navigation was committed or 795 // the tab was closed before that. 796 Hide(); 797 } 798} 799 800void InterstitialPageImpl::TakeActionOnResourceDispatcher( 801 ResourceRequestAction action) { 802 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)) << 803 "TakeActionOnResourceDispatcher should be called on the main thread."; 804 805 if (action == CANCEL || action == RESUME) { 806 if (resource_dispatcher_host_notified_) 807 return; 808 resource_dispatcher_host_notified_ = true; 809 } 810 811 // The tab might not have a render_view_host if it was closed (in which case, 812 // we have taken care of the blocked requests when processing 813 // NOTIFY_RENDER_WIDGET_HOST_DESTROYED. 814 // Also we need to test there is a ResourceDispatcherHostImpl, as when unit- 815 // tests we don't have one. 816 RenderViewHostImpl* rvh = RenderViewHostImpl::FromID(original_child_id_, 817 original_rvh_id_); 818 if (!rvh || !ResourceDispatcherHostImpl::Get()) 819 return; 820 821 BrowserThread::PostTask( 822 BrowserThread::IO, 823 FROM_HERE, 824 base::Bind( 825 &ResourceRequestHelper, 826 ResourceDispatcherHostImpl::Get(), 827 original_child_id_, 828 original_rvh_id_, 829 action)); 830} 831 832void InterstitialPageImpl::OnDomOperationResponse( 833 const std::string& json_string, 834 int automation_id) { 835 // Needed by test code. 836 DomOperationNotificationDetails details(json_string, automation_id); 837 NotificationService::current()->Notify( 838 NOTIFICATION_DOM_OPERATION_RESPONSE, 839 Source<WebContents>(web_contents()), 840 Details<DomOperationNotificationDetails>(&details)); 841 842 if (!enabled()) 843 return; 844 delegate_->CommandReceived(details.json); 845} 846 847 848InterstitialPageImpl::InterstitialPageRVHDelegateView:: 849 InterstitialPageRVHDelegateView(InterstitialPageImpl* page) 850 : interstitial_page_(page) { 851} 852 853#if defined(OS_MACOSX) || defined(OS_ANDROID) 854void InterstitialPageImpl::InterstitialPageRVHDelegateView::ShowPopupMenu( 855 const gfx::Rect& bounds, 856 int item_height, 857 double item_font_size, 858 int selected_item, 859 const std::vector<MenuItem>& items, 860 bool right_aligned, 861 bool allow_multiple_selection) { 862 NOTREACHED() << "InterstitialPage does not support showing popup menus."; 863} 864 865void InterstitialPageImpl::InterstitialPageRVHDelegateView::HidePopupMenu() { 866 NOTREACHED() << "InterstitialPage does not support showing popup menus."; 867} 868#endif 869 870void InterstitialPageImpl::InterstitialPageRVHDelegateView::StartDragging( 871 const DropData& drop_data, 872 WebDragOperationsMask allowed_operations, 873 const gfx::ImageSkia& image, 874 const gfx::Vector2d& image_offset, 875 const DragEventSourceInfo& event_info) { 876 NOTREACHED() << "InterstitialPage does not support dragging yet."; 877} 878 879void InterstitialPageImpl::InterstitialPageRVHDelegateView::UpdateDragCursor( 880 WebDragOperation) { 881 NOTREACHED() << "InterstitialPage does not support dragging yet."; 882} 883 884void InterstitialPageImpl::InterstitialPageRVHDelegateView::GotFocus() { 885 WebContents* web_contents = interstitial_page_->web_contents(); 886 if (web_contents && web_contents->GetDelegate()) 887 web_contents->GetDelegate()->WebContentsFocused(web_contents); 888} 889 890void InterstitialPageImpl::InterstitialPageRVHDelegateView::TakeFocus( 891 bool reverse) { 892 if (!interstitial_page_->web_contents()) 893 return; 894 WebContentsImpl* web_contents = 895 static_cast<WebContentsImpl*>(interstitial_page_->web_contents()); 896 if (!web_contents->GetDelegateView()) 897 return; 898 899 web_contents->GetDelegateView()->TakeFocus(reverse); 900} 901 902void InterstitialPageImpl::InterstitialPageRVHDelegateView::OnFindReply( 903 int request_id, int number_of_matches, const gfx::Rect& selection_rect, 904 int active_match_ordinal, bool final_update) { 905} 906 907} // namespace content 908