interstitial_page_impl.cc revision 010d83a9304c5a91596085d917d248abff47903a
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_delegate_view.h" 23#include "content/browser/renderer_host/render_view_host_factory.h" 24#include "content/browser/renderer_host/render_view_host_impl.h" 25#include "content/browser/renderer_host/render_widget_host_view_base.h" 26#include "content/browser/site_instance_impl.h" 27#include "content/browser/web_contents/web_contents_impl.h" 28#include "content/browser/web_contents/web_contents_view.h" 29#include "content/common/frame_messages.h" 30#include "content/common/view_messages.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 controller_->delegate()->GetRenderViewHost()->GetView()->Focus(); 287 } 288 289 // Delete this and call Shutdown on the RVH asynchronously, as we may have 290 // been called from a RVH delegate method, and we can't delete the RVH out 291 // from under itself. 292 base::MessageLoop::current()->PostNonNestableTask( 293 FROM_HERE, 294 base::Bind(&InterstitialPageImpl::Shutdown, 295 weak_ptr_factory_.GetWeakPtr())); 296 render_view_host_ = NULL; 297 frame_tree_.ResetForMainFrameSwap(); 298 controller_->delegate()->DetachInterstitialPage(); 299 // Let's revert to the original title if necessary. 300 NavigationEntry* entry = controller_->GetVisibleEntry(); 301 if (!new_navigation_ && should_revert_web_contents_title_) { 302 entry->SetTitle(original_web_contents_title_); 303 controller_->delegate()->NotifyNavigationStateChanged( 304 INVALIDATE_TYPE_TITLE); 305 } 306 307 InterstitialPageMap::iterator iter = 308 g_web_contents_to_interstitial_page->find(web_contents_); 309 DCHECK(iter != g_web_contents_to_interstitial_page->end()); 310 if (iter != g_web_contents_to_interstitial_page->end()) 311 g_web_contents_to_interstitial_page->erase(iter); 312 313 // Clear the WebContents pointer, because it may now be deleted. 314 // This signifies that we are in the process of shutting down. 315 web_contents_ = NULL; 316} 317 318void InterstitialPageImpl::Observe( 319 int type, 320 const NotificationSource& source, 321 const NotificationDetails& details) { 322 switch (type) { 323 case NOTIFICATION_NAV_ENTRY_PENDING: 324 // We are navigating away from the interstitial (the user has typed a URL 325 // in the location bar or clicked a bookmark). Make sure clicking on the 326 // interstitial will have no effect. Also cancel any blocked requests 327 // on the ResourceDispatcherHost. Note that when we get this notification 328 // the RenderViewHost has not yet navigated so we'll unblock the 329 // RenderViewHost before the resource request for the new page we are 330 // navigating arrives in the ResourceDispatcherHost. This ensures that 331 // request won't be blocked if the same RenderViewHost was used for the 332 // new navigation. 333 Disable(); 334 TakeActionOnResourceDispatcher(CANCEL); 335 break; 336 case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: 337 if (action_taken_ == NO_ACTION) { 338 // The RenderViewHost is being destroyed (as part of the tab being 339 // closed); make sure we clear the blocked requests. 340 RenderViewHost* rvh = static_cast<RenderViewHost*>( 341 static_cast<RenderViewHostImpl*>( 342 RenderWidgetHostImpl::From( 343 Source<RenderWidgetHost>(source).ptr()))); 344 DCHECK(rvh->GetProcess()->GetID() == original_child_id_ && 345 rvh->GetRoutingID() == original_rvh_id_); 346 TakeActionOnResourceDispatcher(CANCEL); 347 } 348 break; 349 default: 350 NOTREACHED(); 351 } 352} 353 354void InterstitialPageImpl::NavigationEntryCommitted( 355 const LoadCommittedDetails& load_details) { 356 OnNavigatingAwayOrTabClosing(); 357} 358 359void InterstitialPageImpl::WebContentsDestroyed() { 360 OnNavigatingAwayOrTabClosing(); 361} 362 363bool InterstitialPageImpl::OnMessageReceived(RenderFrameHost* render_frame_host, 364 const IPC::Message& message) { 365 return OnMessageReceived(message); 366} 367 368bool InterstitialPageImpl::OnMessageReceived(RenderViewHost* render_view_host, 369 const IPC::Message& message) { 370 return OnMessageReceived(message); 371} 372 373bool InterstitialPageImpl::OnMessageReceived(const IPC::Message& message) { 374 375 bool handled = true; 376 bool message_is_ok = true; 377 IPC_BEGIN_MESSAGE_MAP_EX(InterstitialPageImpl, message, message_is_ok) 378 IPC_MESSAGE_HANDLER(FrameHostMsg_DomOperationResponse, 379 OnDomOperationResponse) 380 IPC_MESSAGE_UNHANDLED(handled = false) 381 IPC_END_MESSAGE_MAP_EX() 382 383 if (!message_is_ok) { 384 RecordAction(base::UserMetricsAction("BadMessageTerminate_RVD")); 385 web_contents()->GetRenderProcessHost()->ReceivedBadMessage(); 386 } 387 388 return handled; 389} 390 391void InterstitialPageImpl::RenderFrameCreated( 392 RenderFrameHost* render_frame_host) { 393 // Note this is only for subframes in the interstitial, the notification for 394 // the main frame happens in RenderViewCreated. 395 controller_->delegate()->RenderFrameForInterstitialPageCreated( 396 render_frame_host); 397} 398 399RenderViewHostDelegateView* InterstitialPageImpl::GetDelegateView() { 400 return rvh_delegate_view_.get(); 401} 402 403const GURL& InterstitialPageImpl::GetMainFrameLastCommittedURL() const { 404 return url_; 405} 406 407void InterstitialPageImpl::RenderViewTerminated( 408 RenderViewHost* render_view_host, 409 base::TerminationStatus status, 410 int error_code) { 411 // Our renderer died. This should not happen in normal cases. 412 // If we haven't already started shutdown, just dismiss the interstitial. 413 // We cannot check for enabled() here, because we may have called Disable 414 // without calling Hide. 415 if (render_view_host_) 416 DontProceed(); 417} 418 419void InterstitialPageImpl::DidNavigate( 420 RenderViewHost* render_view_host, 421 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) { 422 // A fast user could have navigated away from the page that triggered the 423 // interstitial while the interstitial was loading, that would have disabled 424 // us. In that case we can dismiss ourselves. 425 if (!enabled()) { 426 DontProceed(); 427 return; 428 } 429 if (PageTransitionCoreTypeIs(params.transition, 430 PAGE_TRANSITION_AUTO_SUBFRAME)) { 431 // No need to handle navigate message from iframe in the interstitial page. 432 return; 433 } 434 435 // The RenderViewHost has loaded its contents, we can show it now. 436 if (!controller_->delegate()->IsHidden()) 437 render_view_host_->GetView()->Show(); 438 controller_->delegate()->AttachInterstitialPage(this); 439 440 RenderWidgetHostView* rwh_view = 441 controller_->delegate()->GetRenderViewHost()->GetView(); 442 443 // The RenderViewHost may already have crashed before we even get here. 444 if (rwh_view) { 445 // If the page has focus, focus the interstitial. 446 if (rwh_view->HasFocus()) 447 Focus(); 448 449 // Hide the original RVH since we're showing the interstitial instead. 450 rwh_view->Hide(); 451 } 452 453 // Notify the tab we are not loading so the throbber is stopped. It also 454 // causes a WebContentsObserver::DidStopLoading callback that the 455 // AutomationProvider (used by the UI tests) expects to consider a navigation 456 // as complete. Without this, navigating in a UI test to a URL that triggers 457 // an interstitial would hang. 458 web_contents_was_loading_ = controller_->delegate()->IsLoading(); 459 controller_->delegate()->SetIsLoading( 460 controller_->delegate()->GetRenderViewHost(), false, true, NULL); 461} 462 463void InterstitialPageImpl::UpdateTitle( 464 RenderViewHost* render_view_host, 465 int32 page_id, 466 const base::string16& title, 467 base::i18n::TextDirection title_direction) { 468 if (!enabled()) 469 return; 470 471 DCHECK(render_view_host == render_view_host_); 472 NavigationEntry* entry = controller_->GetVisibleEntry(); 473 if (!entry) { 474 // Crash reports from the field indicate this can be NULL. 475 // This is unexpected as InterstitialPages constructed with the 476 // new_navigation flag set to true create a transient navigation entry 477 // (that is returned as the active entry). And the only case so far of 478 // interstitial created with that flag set to false is with the 479 // SafeBrowsingBlockingPage, when the resource triggering the interstitial 480 // is a sub-resource, meaning the main page has already been loaded and a 481 // navigation entry should have been created. 482 NOTREACHED(); 483 return; 484 } 485 486 // If this interstitial is shown on an existing navigation entry, we'll need 487 // to remember its title so we can revert to it when hidden. 488 if (!new_navigation_ && !should_revert_web_contents_title_) { 489 original_web_contents_title_ = entry->GetTitle(); 490 should_revert_web_contents_title_ = true; 491 } 492 // TODO(evan): make use of title_direction. 493 // http://code.google.com/p/chromium/issues/detail?id=27094 494 entry->SetTitle(title); 495 controller_->delegate()->NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE); 496} 497 498RendererPreferences InterstitialPageImpl::GetRendererPrefs( 499 BrowserContext* browser_context) const { 500 delegate_->OverrideRendererPrefs(&renderer_preferences_); 501 return renderer_preferences_; 502} 503 504WebPreferences InterstitialPageImpl::GetWebkitPrefs() { 505 if (!enabled()) 506 return WebPreferences(); 507 508 return render_view_host_->GetWebkitPrefs(url_); 509} 510 511void InterstitialPageImpl::RenderWidgetDeleted( 512 RenderWidgetHostImpl* render_widget_host) { 513 // TODO(creis): Remove this method once we verify the shutdown path is sane. 514 CHECK(!web_contents_); 515} 516 517bool InterstitialPageImpl::PreHandleKeyboardEvent( 518 const NativeWebKeyboardEvent& event, 519 bool* is_keyboard_shortcut) { 520 if (!enabled()) 521 return false; 522 return render_widget_host_delegate_->PreHandleKeyboardEvent( 523 event, is_keyboard_shortcut); 524} 525 526void InterstitialPageImpl::HandleKeyboardEvent( 527 const NativeWebKeyboardEvent& event) { 528 if (enabled()) 529 render_widget_host_delegate_->HandleKeyboardEvent(event); 530} 531 532#if defined(OS_WIN) 533gfx::NativeViewAccessible 534InterstitialPageImpl::GetParentNativeViewAccessible() { 535 return render_widget_host_delegate_->GetParentNativeViewAccessible(); 536} 537#endif 538 539WebContents* InterstitialPageImpl::web_contents() const { 540 return web_contents_; 541} 542 543RenderViewHost* InterstitialPageImpl::CreateRenderViewHost() { 544 if (!enabled()) 545 return NULL; 546 547 // Interstitial pages don't want to share the session storage so we mint a 548 // new one. 549 BrowserContext* browser_context = web_contents()->GetBrowserContext(); 550 scoped_refptr<SiteInstance> site_instance = 551 SiteInstance::Create(browser_context); 552 DOMStorageContextWrapper* dom_storage_context = 553 static_cast<DOMStorageContextWrapper*>( 554 BrowserContext::GetStoragePartition( 555 browser_context, site_instance.get())->GetDOMStorageContext()); 556 session_storage_namespace_ = 557 new SessionStorageNamespaceImpl(dom_storage_context); 558 559 // Use the RenderViewHost from our FrameTree. 560 frame_tree_.root()->render_manager()->Init( 561 browser_context, site_instance.get(), MSG_ROUTING_NONE, MSG_ROUTING_NONE); 562 return frame_tree_.root()->current_frame_host()->render_view_host(); 563} 564 565WebContentsView* InterstitialPageImpl::CreateWebContentsView() { 566 if (!enabled() || !create_view_) 567 return NULL; 568 WebContentsView* wcv = 569 static_cast<WebContentsImpl*>(web_contents())->GetView(); 570 RenderWidgetHostViewBase* view = 571 wcv->CreateViewForWidget(render_view_host_); 572 render_view_host_->SetView(view); 573 render_view_host_->AllowBindings(BINDINGS_POLICY_DOM_AUTOMATION); 574 575 int32 max_page_id = web_contents()-> 576 GetMaxPageIDForSiteInstance(render_view_host_->GetSiteInstance()); 577 render_view_host_->CreateRenderView(base::string16(), 578 MSG_ROUTING_NONE, 579 max_page_id, 580 false); 581 controller_->delegate()->RenderFrameForInterstitialPageCreated( 582 frame_tree_.root()->current_frame_host()); 583 view->SetSize(web_contents()->GetContainerBounds().size()); 584 // Don't show the interstitial until we have navigated to it. 585 view->Hide(); 586 return wcv; 587} 588 589void InterstitialPageImpl::Proceed() { 590 // Don't repeat this if we are already shutting down. We cannot check for 591 // enabled() here, because we may have called Disable without calling Hide. 592 if (!render_view_host_) 593 return; 594 595 if (action_taken_ != NO_ACTION) { 596 NOTREACHED(); 597 return; 598 } 599 Disable(); 600 action_taken_ = PROCEED_ACTION; 601 602 // Resumes the throbber, if applicable. 603 if (web_contents_was_loading_) 604 controller_->delegate()->SetIsLoading( 605 controller_->delegate()->GetRenderViewHost(), true, true, NULL); 606 607 // If this is a new navigation, the old page is going away, so we cancel any 608 // blocked requests for it. If it is not a new navigation, then it means the 609 // interstitial was shown as a result of a resource loading in the page. 610 // Since the user wants to proceed, we'll let any blocked request go through. 611 if (new_navigation_) 612 TakeActionOnResourceDispatcher(CANCEL); 613 else 614 TakeActionOnResourceDispatcher(RESUME); 615 616 // No need to hide if we are a new navigation, we'll get hidden when the 617 // navigation is committed. 618 if (!new_navigation_) { 619 Hide(); 620 delegate_->OnProceed(); 621 return; 622 } 623 624 delegate_->OnProceed(); 625} 626 627void InterstitialPageImpl::DontProceed() { 628 // Don't repeat this if we are already shutting down. We cannot check for 629 // enabled() here, because we may have called Disable without calling Hide. 630 if (!render_view_host_) 631 return; 632 DCHECK(action_taken_ != DONT_PROCEED_ACTION); 633 634 Disable(); 635 action_taken_ = DONT_PROCEED_ACTION; 636 637 // If this is a new navigation, we are returning to the original page, so we 638 // resume blocked requests for it. If it is not a new navigation, then it 639 // means the interstitial was shown as a result of a resource loading in the 640 // page and we won't return to the original page, so we cancel blocked 641 // requests in that case. 642 if (new_navigation_) 643 TakeActionOnResourceDispatcher(RESUME); 644 else 645 TakeActionOnResourceDispatcher(CANCEL); 646 647 if (should_discard_pending_nav_entry_) { 648 // Since no navigation happens we have to discard the transient entry 649 // explicitely. Note that by calling DiscardNonCommittedEntries() we also 650 // discard the pending entry, which is what we want, since the navigation is 651 // cancelled. 652 controller_->DiscardNonCommittedEntries(); 653 } 654 655 if (reload_on_dont_proceed_) 656 controller_->Reload(true); 657 658 Hide(); 659 delegate_->OnDontProceed(); 660} 661 662void InterstitialPageImpl::CancelForNavigation() { 663 // The user is trying to navigate away. We should unblock the renderer and 664 // disable the interstitial, but keep it visible until the navigation 665 // completes. 666 Disable(); 667 // If this interstitial was shown for a new navigation, allow any navigations 668 // on the original page to resume (e.g., subresource requests, XHRs, etc). 669 // Otherwise, cancel the pending, possibly dangerous navigations. 670 if (new_navigation_) 671 TakeActionOnResourceDispatcher(RESUME); 672 else 673 TakeActionOnResourceDispatcher(CANCEL); 674} 675 676void InterstitialPageImpl::SetSize(const gfx::Size& size) { 677 if (!enabled()) 678 return; 679#if !defined(OS_MACOSX) 680 // When a tab is closed, we might be resized after our view was NULLed 681 // (typically if there was an info-bar). 682 if (render_view_host_->GetView()) 683 render_view_host_->GetView()->SetSize(size); 684#else 685 // TODO(port): Does Mac need to SetSize? 686 NOTIMPLEMENTED(); 687#endif 688} 689 690void InterstitialPageImpl::Focus() { 691 // Focus the native window. 692 if (!enabled()) 693 return; 694 render_view_host_->GetView()->Focus(); 695} 696 697void InterstitialPageImpl::FocusThroughTabTraversal(bool reverse) { 698 if (!enabled()) 699 return; 700 render_view_host_->SetInitialFocus(reverse); 701} 702 703RenderWidgetHostView* InterstitialPageImpl::GetView() { 704 return render_view_host_->GetView(); 705} 706 707RenderViewHost* InterstitialPageImpl::GetRenderViewHostForTesting() const { 708 return render_view_host_; 709} 710 711#if defined(OS_ANDROID) 712RenderViewHost* InterstitialPageImpl::GetRenderViewHost() const { 713 return render_view_host_; 714} 715#endif 716 717InterstitialPageDelegate* InterstitialPageImpl::GetDelegateForTesting() { 718 return delegate_.get(); 719} 720 721void InterstitialPageImpl::DontCreateViewForTesting() { 722 create_view_ = false; 723} 724 725gfx::Rect InterstitialPageImpl::GetRootWindowResizerRect() const { 726 return gfx::Rect(); 727} 728 729void InterstitialPageImpl::CreateNewWindow( 730 int render_process_id, 731 int route_id, 732 int main_frame_route_id, 733 const ViewHostMsg_CreateWindow_Params& params, 734 SessionStorageNamespace* session_storage_namespace) { 735 NOTREACHED() << "InterstitialPage does not support showing popups yet."; 736} 737 738void InterstitialPageImpl::CreateNewWidget(int render_process_id, 739 int route_id, 740 blink::WebPopupType popup_type) { 741 NOTREACHED() << "InterstitialPage does not support showing drop-downs yet."; 742} 743 744void InterstitialPageImpl::CreateNewFullscreenWidget(int render_process_id, 745 int route_id) { 746 NOTREACHED() 747 << "InterstitialPage does not support showing full screen popups."; 748} 749 750void InterstitialPageImpl::ShowCreatedWindow(int route_id, 751 WindowOpenDisposition disposition, 752 const gfx::Rect& initial_pos, 753 bool user_gesture) { 754 NOTREACHED() << "InterstitialPage does not support showing popups yet."; 755} 756 757void InterstitialPageImpl::ShowCreatedWidget(int route_id, 758 const gfx::Rect& initial_pos) { 759 NOTREACHED() << "InterstitialPage does not support showing drop-downs yet."; 760} 761 762void InterstitialPageImpl::ShowCreatedFullscreenWidget(int route_id) { 763 NOTREACHED() 764 << "InterstitialPage does not support showing full screen popups."; 765} 766 767SessionStorageNamespace* InterstitialPageImpl::GetSessionStorageNamespace( 768 SiteInstance* instance) { 769 return session_storage_namespace_.get(); 770} 771 772FrameTree* InterstitialPageImpl::GetFrameTree() { 773 return &frame_tree_; 774} 775 776void InterstitialPageImpl::Disable() { 777 enabled_ = false; 778} 779 780void InterstitialPageImpl::Shutdown() { 781 delete this; 782} 783 784void InterstitialPageImpl::OnNavigatingAwayOrTabClosing() { 785 if (action_taken_ == NO_ACTION) { 786 // We are navigating away from the interstitial or closing a tab with an 787 // interstitial. Default to DontProceed(). We don't just call Hide as 788 // subclasses will almost certainly override DontProceed to do some work 789 // (ex: close pending connections). 790 DontProceed(); 791 } else { 792 // User decided to proceed and either the navigation was committed or 793 // the tab was closed before that. 794 Hide(); 795 } 796} 797 798void InterstitialPageImpl::TakeActionOnResourceDispatcher( 799 ResourceRequestAction action) { 800 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)) << 801 "TakeActionOnResourceDispatcher should be called on the main thread."; 802 803 if (action == CANCEL || action == RESUME) { 804 if (resource_dispatcher_host_notified_) 805 return; 806 resource_dispatcher_host_notified_ = true; 807 } 808 809 // The tab might not have a render_view_host if it was closed (in which case, 810 // we have taken care of the blocked requests when processing 811 // NOTIFY_RENDER_WIDGET_HOST_DESTROYED. 812 // Also we need to test there is a ResourceDispatcherHostImpl, as when unit- 813 // tests we don't have one. 814 RenderViewHostImpl* rvh = RenderViewHostImpl::FromID(original_child_id_, 815 original_rvh_id_); 816 if (!rvh || !ResourceDispatcherHostImpl::Get()) 817 return; 818 819 BrowserThread::PostTask( 820 BrowserThread::IO, 821 FROM_HERE, 822 base::Bind( 823 &ResourceRequestHelper, 824 ResourceDispatcherHostImpl::Get(), 825 original_child_id_, 826 original_rvh_id_, 827 action)); 828} 829 830void InterstitialPageImpl::OnDomOperationResponse( 831 const std::string& json_string, 832 int automation_id) { 833 // Needed by test code. 834 DomOperationNotificationDetails details(json_string, automation_id); 835 NotificationService::current()->Notify( 836 NOTIFICATION_DOM_OPERATION_RESPONSE, 837 Source<WebContents>(web_contents()), 838 Details<DomOperationNotificationDetails>(&details)); 839 840 if (!enabled()) 841 return; 842 delegate_->CommandReceived(details.json); 843} 844 845 846InterstitialPageImpl::InterstitialPageRVHDelegateView:: 847 InterstitialPageRVHDelegateView(InterstitialPageImpl* page) 848 : interstitial_page_(page) { 849} 850 851#if defined(OS_MACOSX) || defined(OS_ANDROID) 852void InterstitialPageImpl::InterstitialPageRVHDelegateView::ShowPopupMenu( 853 const gfx::Rect& bounds, 854 int item_height, 855 double item_font_size, 856 int selected_item, 857 const std::vector<MenuItem>& items, 858 bool right_aligned, 859 bool allow_multiple_selection) { 860 NOTREACHED() << "InterstitialPage does not support showing popup menus."; 861} 862 863void InterstitialPageImpl::InterstitialPageRVHDelegateView::HidePopupMenu() { 864 NOTREACHED() << "InterstitialPage does not support showing popup menus."; 865} 866#endif 867 868void InterstitialPageImpl::InterstitialPageRVHDelegateView::StartDragging( 869 const DropData& drop_data, 870 WebDragOperationsMask allowed_operations, 871 const gfx::ImageSkia& image, 872 const gfx::Vector2d& image_offset, 873 const DragEventSourceInfo& event_info) { 874 interstitial_page_->render_view_host_->DragSourceSystemDragEnded(); 875 DVLOG(1) << "InterstitialPage does not support dragging yet."; 876} 877 878void InterstitialPageImpl::InterstitialPageRVHDelegateView::UpdateDragCursor( 879 WebDragOperation) { 880 NOTREACHED() << "InterstitialPage does not support dragging yet."; 881} 882 883void InterstitialPageImpl::InterstitialPageRVHDelegateView::GotFocus() { 884 WebContents* web_contents = interstitial_page_->web_contents(); 885 if (web_contents && web_contents->GetDelegate()) 886 web_contents->GetDelegate()->WebContentsFocused(web_contents); 887} 888 889void InterstitialPageImpl::InterstitialPageRVHDelegateView::TakeFocus( 890 bool reverse) { 891 if (!interstitial_page_->web_contents()) 892 return; 893 WebContentsImpl* web_contents = 894 static_cast<WebContentsImpl*>(interstitial_page_->web_contents()); 895 if (!web_contents->GetDelegateView()) 896 return; 897 898 web_contents->GetDelegateView()->TakeFocus(reverse); 899} 900 901void InterstitialPageImpl::InterstitialPageRVHDelegateView::OnFindReply( 902 int request_id, int number_of_matches, const gfx::Rect& selection_rect, 903 int active_match_ordinal, bool final_update) { 904} 905 906} // namespace content 907