Don't show current RenderWidgetHostView while interstitial is showing.

content/browser/web_contents/web_contents_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/web_contents/web_contents_impl.h"
 
 #include <stddef.h>
 
 #include <cmath>
 #include <utility>
@@ skipping 470 matching lines @@
                   this),
       node_(this),
       is_load_to_different_document_(false),
       crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
       crashed_error_code_(0),
       waiting_for_response_(false),
       load_state_(net::LOAD_STATE_IDLE, base::string16()),
       upload_size_(0),
       upload_position_(0),
       is_resume_pending_(false),
+      interstitial_page_(nullptr),
       has_accessed_initial_document_(false),
       theme_color_(SK_ColorTRANSPARENT),
       last_sent_theme_color_(SK_ColorTRANSPARENT),
       did_first_visually_non_empty_paint_(false),
       capturer_count_(0),
       should_normally_be_visible_(true),
       did_first_set_visible_(false),
       is_being_destroyed_(false),
       is_notifying_observers_(false),
       notify_disconnection_(false),
@@ skipping 778 matching lines @@
 SiteInstanceImpl* WebContentsImpl::GetPendingSiteInstance() const {
   RenderViewHostImpl* dest_rvh =
       GetRenderManager()->pending_render_view_host() ?
           GetRenderManager()->pending_render_view_host() :
           GetRenderManager()->current_host();
   return dest_rvh->GetSiteInstance();
 }
 
 bool WebContentsImpl::IsLoading() const {
   return frame_tree_.IsLoading() &&
-         !(ShowingInterstitialPage() &&
-           GetRenderManager()->interstitial_page()->pause_throbber());
+         !(ShowingInterstitialPage() && interstitial_page_->pause_throbber());
 }
 
 bool WebContentsImpl::IsLoadingToDifferentDocument() const {
   return IsLoading() && is_load_to_different_document_;
 }
 
 bool WebContentsImpl::IsWaitingForResponse() const {
   return waiting_for_response_ && is_load_to_different_document_;
 }
 
@@ skipping 668 matching lines @@
   // forwarded directly to the widget they arrived on.
   if (receiving_widget != GetMainFrame()->GetRenderWidgetHost())
     return receiving_widget;
 
   WebContentsImpl* focused_contents = GetFocusedWebContents();
 
   // If the focused WebContents is showing an interstitial, return the
   // interstitial's widget.
   if (focused_contents->ShowingInterstitialPage()) {
     return static_cast<RenderFrameHostImpl*>(
-               focused_contents->GetRenderManager()
-                   ->interstitial_page()
-                   ->GetMainFrame())
+               focused_contents->interstitial_page_->GetMainFrame())
         ->GetRenderWidgetHost();
   }
 
   // If the focused WebContents is a guest WebContents, then get the focused
   // frame in the embedder WebContents instead.
   FrameTreeNode* focused_frame = nullptr;
   if (focused_contents->browser_plugin_guest_ &&
       !GuestMode::IsCrossProcessFrameGuest(focused_contents)) {
     focused_frame = frame_tree_.GetFocusedFrame();
   } else {
@@ skipping 12 matching lines @@
     return nullptr;
 
   return RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
 }
 
 RenderWidgetHostImpl* WebContentsImpl::GetRenderWidgetHostWithPageFocus() {
   WebContentsImpl* focused_web_contents = GetFocusedWebContents();
 
   if (focused_web_contents->ShowingInterstitialPage()) {
     return static_cast<RenderFrameHostImpl*>(
-               focused_web_contents->GetRenderManager()
-                   ->interstitial_page()
-                   ->GetMainFrame())
+               focused_web_contents->interstitial_page_->GetMainFrame())
         ->GetRenderWidgetHost();
   }
 
   return focused_web_contents->GetMainFrame()->GetRenderWidgetHost();
 }
 
 void WebContentsImpl::EnterFullscreenMode(const GURL& origin) {
   // This method is being called to enter renderer-initiated fullscreen mode.
   // Make sure any existing fullscreen widget is shut down first.
   RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
@@ skipping 823 matching lines @@
 }
 
 void WebContentsImpl::RenderFrameForInterstitialPageCreated(
     RenderFrameHost* render_frame_host) {
   for (auto& observer : observers_)
     observer.RenderFrameForInterstitialPageCreated(render_frame_host);
 }
 
 void WebContentsImpl::AttachInterstitialPage(
     InterstitialPageImpl* interstitial_page) {
-  DCHECK(interstitial_page);
-  GetRenderManager()->set_interstitial_page(interstitial_page);
+  DCHECK(!interstitial_page_ && interstitial_page);
+  interstitial_page_ = interstitial_page;
 
   // Cancel any visible dialogs so that they don't interfere with the
   // interstitial.
   CancelActiveAndPendingDialogs();
 
   for (auto& observer : observers_)
     observer.DidAttachInterstitialPage();
 
   // Stop the throbber if needed while the interstitial page is shown.
   if (frame_tree_.IsLoading())
     LoadingStateChanged(true, true, nullptr);
 
   // Connect to outer WebContents if necessary.
   if (node_.OuterContentsFrameTreeNode()) {
     if (GetRenderManager()->GetProxyToOuterDelegate()) {
       DCHECK(
           static_cast<RenderWidgetHostViewBase*>(interstitial_page->GetView())
               ->IsRenderWidgetHostViewChildFrame());
       RenderWidgetHostViewChildFrame* view =
           static_cast<RenderWidgetHostViewChildFrame*>(
               interstitial_page->GetView());
       GetRenderManager()->SetRWHViewForInnerContents(view);
     }
   }
 }
 
 void WebContentsImpl::DidProceedOnInterstitial() {
   // The interstitial page should no longer be pausing the throbber.
-  DCHECK(!(ShowingInterstitialPage() &&
-           GetRenderManager()->interstitial_page()->pause_throbber()));
+  DCHECK(!(ShowingInterstitialPage() && interstitial_page_->pause_throbber()));
 
   // Restart the throbber now that the interstitial page no longer pauses it.
   if (ShowingInterstitialPage() && frame_tree_.IsLoading())
     LoadingStateChanged(true, true, nullptr);
 }
 
 void WebContentsImpl::DetachInterstitialPage() {
   // Disconnect from outer WebContents if necessary.
   if (node_.OuterContentsFrameTreeNode()) {
     if (GetRenderManager()->GetProxyToOuterDelegate()) {
       DCHECK(static_cast<RenderWidgetHostViewBase*>(
                  GetRenderManager()->current_frame_host()->GetView())
                  ->IsRenderWidgetHostViewChildFrame());
       RenderWidgetHostViewChildFrame* view =
           static_cast<RenderWidgetHostViewChildFrame*>(
               GetRenderManager()->current_frame_host()->GetView());
       GetRenderManager()->SetRWHViewForInnerContents(view);
     }
   }
 
   bool interstitial_pausing_throbber =
-      ShowingInterstitialPage() &&
-      GetRenderManager()->interstitial_page()->pause_throbber();
+      ShowingInterstitialPage() && interstitial_page_->pause_throbber();
   if (ShowingInterstitialPage())
-    GetRenderManager()->remove_interstitial_page();
+    interstitial_page_ = nullptr;
   for (auto& observer : observers_)
     observer.DidDetachInterstitialPage();
 
   // Restart the throbber if needed now that the interstitial page is going
   // away.
   if (interstitial_pausing_throbber && frame_tree_.IsLoading())
     LoadingStateChanged(true, true, nullptr);
 }
 
 void WebContentsImpl::SetHistoryOffsetAndLength(int history_offset,
@@ skipping 187 matching lines @@
 void WebContentsImpl::StoreFocus() {
   view_->StoreFocus();
 }
 
 void WebContentsImpl::RestoreFocus() {
   view_->RestoreFocus();
 }
 
 void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
   if (ShowingInterstitialPage()) {
-    GetRenderManager()->interstitial_page()->FocusThroughTabTraversal(reverse);
+    interstitial_page_->FocusThroughTabTraversal(reverse);
     return;
   }
   RenderWidgetHostView* const fullscreen_view =
       GetFullscreenRenderWidgetHostView();
   if (fullscreen_view) {
     fullscreen_view->Focus();
     return;
   }
   GetRenderViewHost()->SetInitialFocus(reverse);
 }
 
 bool WebContentsImpl::ShowingInterstitialPage() const {
-  return GetRenderManager()->interstitial_page() != NULL;
+  return interstitial_page_ != nullptr;
 }
 
 InterstitialPage* WebContentsImpl::GetInterstitialPage() const {
-  return GetRenderManager()->interstitial_page();
+  return interstitial_page_;
 }
 
 bool WebContentsImpl::IsSavable() {
   // WebKit creates Document object when MIME type is application/xhtml+xml,
   // so we also support this MIME type.
   return contents_mime_type_ == "text/html" ||
          contents_mime_type_ == "text/xml" ||
          contents_mime_type_ == "application/xhtml+xml" ||
          contents_mime_type_ == "text/plain" ||
          contents_mime_type_ == "text/css" ||
@@ skipping 1117 matching lines @@
   loading_last_progress_update_ = base::TimeTicks();
 }
 
 // Notifies the RenderWidgetHost instance about the fact that the page is
 // loading, or done loading.
 void WebContentsImpl::LoadingStateChanged(bool to_different_document,
                                           bool due_to_interstitial,
                                           LoadNotificationDetails* details) {
   // Do not send notifications about loading changes in the FrameTree while the
   // interstitial page is pausing the throbber.
-  if (ShowingInterstitialPage() &&
-      GetRenderManager()->interstitial_page()->pause_throbber() &&
+  if (ShowingInterstitialPage() && interstitial_page_->pause_throbber() &&
       !due_to_interstitial) {
     return;
   }
 
   bool is_loading = IsLoading();
 
   if (!is_loading) {
     load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
                                           base::string16());
     load_state_host_.clear();
@@ skipping 709 matching lines @@
   if (old_contents)
     old_contents->GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(false);
 
   // Make sure the outer web contents knows our frame is focused. Otherwise, the
   // outer renderer could have the element before or after the frame element
   // focused which would return early without actually advancing focus.
   if (GetRenderManager()->GetProxyToOuterDelegate())
     GetRenderManager()->GetProxyToOuterDelegate()->SetFocusedFrame();
 
   if (ShowingInterstitialPage()) {
-    static_cast<RenderFrameHostImpl*>(
-        GetRenderManager()->interstitial_page()->GetMainFrame())
+    static_cast<RenderFrameHostImpl*>(interstitial_page_->GetMainFrame())
         ->GetRenderWidgetHost()
         ->SetPageFocus(true);
   } else {
     GetMainFrame()->GetRenderWidgetHost()->SetPageFocus(true);
   }
 }
 
 void WebContentsImpl::SetFocusedFrame(FrameTreeNode* node,
                                       SiteInstance* source) {
   SetAsFocusedWebContentsIfNecessary();
@@ skipping 188 matching lines @@
 std::unique_ptr<WebUIImpl> WebContentsImpl::CreateWebUIForRenderFrameHost(
     const GURL& url) {
   return CreateWebUI(url, std::string());
 }
 
 NavigationEntry*
     WebContentsImpl::GetLastCommittedNavigationEntryForRenderManager() {
   return controller_.GetLastCommittedEntry();
 }
 
+InterstitialPageImpl* WebContentsImpl::GetInterstitialForRenderManager() {
+  return interstitial_page_;
+}
+
 void WebContentsImpl::CreateRenderWidgetHostViewForRenderManager(
     RenderViewHost* render_view_host) {
   RenderWidgetHostViewBase* rwh_view =
       view_->CreateViewForWidget(render_view_host->GetWidget(), false);
 
   // Now that the RenderView has been created, we need to tell it its size.
   if (rwh_view)
     rwh_view->SetSize(GetSizeForNewRenderView());
 }
 
@@ skipping 504 matching lines @@
     new_root->SetOriginalOpener(opener->frame_tree()->root());
 
     if (!opener_suppressed) {
       new_root->SetOpener(opener);
       created_with_opener_ = true;
     }
   }
 }
 
 }  // namespace content