diff options
Diffstat (limited to 'content/browser/frame_host/render_frame_host_manager.cc')
| -rw-r--r-- | content/browser/frame_host/render_frame_host_manager.cc | 614 |
1 files changed, 241 insertions, 373 deletions
diff --git a/content/browser/frame_host/render_frame_host_manager.cc b/content/browser/frame_host/render_frame_host_manager.cc index b5e1d48..8b7448d 100644 --- a/content/browser/frame_host/render_frame_host_manager.cc +++ b/content/browser/frame_host/render_frame_host_manager.cc @@ -14,8 +14,6 @@ #include "content/browser/frame_host/interstitial_page_impl.h" #include "content/browser/frame_host/navigation_controller_impl.h" #include "content/browser/frame_host/navigation_entry_impl.h" -#include "content/browser/frame_host/render_frame_host_factory.h" -#include "content/browser/frame_host/render_frame_host_impl.h" #include "content/browser/renderer_host/render_process_host_impl.h" #include "content/browser/renderer_host/render_view_host_factory.h" #include "content/browser/renderer_host/render_view_host_impl.h" @@ -59,55 +57,53 @@ RenderFrameHostManager::PendingNavigationParams::PendingNavigationParams( RenderFrameHostManager::PendingNavigationParams::~PendingNavigationParams() {} RenderFrameHostManager::RenderFrameHostManager( - FrameTreeNode* frame_tree_node, RenderFrameHostDelegate* render_frame_delegate, RenderViewHostDelegate* render_view_delegate, RenderWidgetHostDelegate* render_widget_delegate, Delegate* delegate) - : frame_tree_node_(frame_tree_node), - delegate_(delegate), + : delegate_(delegate), cross_navigation_pending_(false), render_frame_delegate_(render_frame_delegate), render_view_delegate_(render_view_delegate), render_widget_delegate_(render_widget_delegate), - render_frame_host_(NULL), - pending_render_frame_host_(NULL), + render_view_host_(NULL), + pending_render_view_host_(NULL), interstitial_page_(NULL) { } RenderFrameHostManager::~RenderFrameHostManager() { - if (pending_render_frame_host_) + if (pending_render_view_host_) CancelPending(); - // We should always have a current RenderFrameHost except in some tests. - // TODO(creis): Now that we aren't using Shutdown, make render_frame_host_ and - // RenderFrameHostMap use scoped_ptrs. - RenderFrameHostImpl* render_frame_host = render_frame_host_; - render_frame_host_ = NULL; - if (render_frame_host) - delete render_frame_host; + // We should always have a main RenderViewHost except in some tests. + RenderViewHostImpl* render_view_host = render_view_host_; + render_view_host_ = NULL; + if (render_view_host) + render_view_host->Shutdown(); - // Delete any swapped out RenderFrameHosts. - for (RenderFrameHostMap::iterator iter = swapped_out_hosts_.begin(); + // Shut down any swapped out RenderViewHosts. + for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin(); iter != swapped_out_hosts_.end(); ++iter) { - delete iter->second; + iter->second->Shutdown(); } } void RenderFrameHostManager::Init(BrowserContext* browser_context, SiteInstance* site_instance, - int view_routing_id, - int frame_routing_id) { - // Create a RenderViewHost and RenderFrameHost, once we have an instance. It - // is important to immediately give this SiteInstance to a RenderViewHost so - // that the SiteInstance is ref counted. + int routing_id, + int main_frame_routing_id) { + // Create a RenderViewHost, once we have an instance. It is important to + // immediately give this SiteInstance to a RenderViewHost so that it is + // ref counted. if (!site_instance) site_instance = SiteInstance::Create(browser_context); - - // TODO(creis): Make render_frame_host_ a scoped_ptr. - render_frame_host_ = CreateRenderFrameHost(site_instance, view_routing_id, - frame_routing_id, false, false); + render_view_host_ = static_cast<RenderViewHostImpl*>( + RenderViewHostFactory::Create( + site_instance, render_view_delegate_, render_frame_delegate_, + render_widget_delegate_, routing_id, main_frame_routing_id, false, + delegate_->IsHidden())); + render_view_host_->AttachToFrameTree(); // Keep track of renderer processes as they start to shut down or are // crashed/killed. @@ -118,23 +114,19 @@ void RenderFrameHostManager::Init(BrowserContext* browser_context, } RenderViewHostImpl* RenderFrameHostManager::current_host() const { - if (!render_frame_host_) - return NULL; - return render_frame_host_->render_view_host(); + return render_view_host_; } RenderViewHostImpl* RenderFrameHostManager::pending_render_view_host() const { - if (!pending_render_frame_host_) - return NULL; - return pending_render_frame_host_->render_view_host(); + return pending_render_view_host_; } RenderWidgetHostView* RenderFrameHostManager::GetRenderWidgetHostView() const { if (interstitial_page_) return interstitial_page_->GetView(); - if (!render_frame_host_) + if (!render_view_host_) return NULL; - return render_frame_host_->render_view_host()->GetView(); + return render_view_host_->GetView(); } void RenderFrameHostManager::SetPendingWebUI(const NavigationEntryImpl& entry) { @@ -157,111 +149,103 @@ void RenderFrameHostManager::SetPendingWebUI(const NavigationEntryImpl& entry) { RenderViewHostImpl* RenderFrameHostManager::Navigate( const NavigationEntryImpl& entry) { TRACE_EVENT0("browser", "RenderFrameHostManager:Navigate"); - // Create a pending RenderFrameHost to use for the navigation. - RenderFrameHostImpl* dest_render_frame_host = - UpdateRendererStateForNavigate(entry); - if (!dest_render_frame_host) - return NULL; // We weren't able to create a pending render frame host. - - // If the current render_frame_host_ isn't live, we should create it so - // that we don't show a sad tab while the dest_render_frame_host fetches + // Create a pending RenderViewHost. It will give us the one we should use + RenderViewHostImpl* dest_render_view_host = + static_cast<RenderViewHostImpl*>(UpdateRendererStateForNavigate(entry)); + if (!dest_render_view_host) + return NULL; // We weren't able to create a pending render view host. + + // If the current render_view_host_ isn't live, we should create it so + // that we don't show a sad tab while the dest_render_view_host fetches // its first page. (Bug 1145340) - if (dest_render_frame_host != render_frame_host_ && - !render_frame_host_->render_view_host()->IsRenderViewLive()) { + if (dest_render_view_host != render_view_host_ && + !render_view_host_->IsRenderViewLive()) { // Note: we don't call InitRenderView here because we are navigating away // soon anyway, and we don't have the NavigationEntry for this host. - delegate_->CreateRenderViewForRenderManager( - render_frame_host_->render_view_host(), MSG_ROUTING_NONE); + delegate_->CreateRenderViewForRenderManager(render_view_host_, + MSG_ROUTING_NONE); } // If the renderer crashed, then try to create a new one to satisfy this // navigation request. - if (!dest_render_frame_host->render_view_host()->IsRenderViewLive()) { + if (!dest_render_view_host->IsRenderViewLive()) { // Recreate the opener chain. int opener_route_id = delegate_->CreateOpenerRenderViewsForRenderManager( - dest_render_frame_host->render_view_host()->GetSiteInstance()); - if (!InitRenderView(dest_render_frame_host->render_view_host(), - opener_route_id)) + dest_render_view_host->GetSiteInstance()); + if (!InitRenderView(dest_render_view_host, opener_route_id)) return NULL; // Now that we've created a new renderer, be sure to hide it if it isn't // our primary one. Otherwise, we might crash if we try to call Show() // on it later. - if (dest_render_frame_host != render_frame_host_ && - dest_render_frame_host->render_view_host()->GetView()) { - dest_render_frame_host->render_view_host()->GetView()->Hide(); + if (dest_render_view_host != render_view_host_ && + dest_render_view_host->GetView()) { + dest_render_view_host->GetView()->Hide(); } else { // This is our primary renderer, notify here as we won't be calling // CommitPending (which does the notify). - delegate_->NotifySwappedFromRenderManager( - NULL, render_frame_host_->render_view_host()); + delegate_->NotifySwappedFromRenderManager(NULL, render_view_host_); } } - // TODO(creis): Return the RFH instead, once we can navigate RFHs. - return dest_render_frame_host->render_view_host(); + return dest_render_view_host; } void RenderFrameHostManager::Stop() { - render_frame_host_->render_view_host()->Stop(); + render_view_host_->Stop(); // If we are cross-navigating, we should stop the pending renderers. This // will lead to a DidFailProvisionalLoad, which will properly destroy them. if (cross_navigation_pending_) { - pending_render_frame_host_->render_view_host()->Send(new ViewMsg_Stop( - pending_render_frame_host_->render_view_host()->GetRoutingID())); + pending_render_view_host_->Send( + new ViewMsg_Stop(pending_render_view_host_->GetRoutingID())); } } void RenderFrameHostManager::SetIsLoading(bool is_loading) { - render_frame_host_->render_view_host()->SetIsLoading(is_loading); - if (pending_render_frame_host_) - pending_render_frame_host_->render_view_host()->SetIsLoading(is_loading); + render_view_host_->SetIsLoading(is_loading); + if (pending_render_view_host_) + pending_render_view_host_->SetIsLoading(is_loading); } bool RenderFrameHostManager::ShouldCloseTabOnUnresponsiveRenderer() { if (!cross_navigation_pending_) return true; - // We should always have a pending RFH when there's a cross-process navigation + // We should always have a pending RVH when there's a cross-process navigation // in progress. Sanity check this for http://crbug.com/276333. - CHECK(pending_render_frame_host_); + CHECK(pending_render_view_host_); // If the tab becomes unresponsive during {before}unload while doing a // cross-site navigation, proceed with the navigation. (This assumes that - // the pending RenderFrameHost is still responsive.) - if (render_frame_host_->render_view_host()->is_waiting_for_unload_ack()) { + // the pending RenderViewHost is still responsive.) + if (render_view_host_->is_waiting_for_unload_ack()) { // The request has been started and paused while we're waiting for the // unload handler to finish. We'll pretend that it did. The pending // renderer will then be swapped in as part of the usual DidNavigate logic. // (If the unload handler later finishes, this call will be ignored because // the pending_nav_params_ state will already be cleaned up.) current_host()->OnSwappedOut(true); - } else if (render_frame_host_->render_view_host()-> - is_waiting_for_beforeunload_ack()) { + } else if (render_view_host_->is_waiting_for_beforeunload_ack()) { // Haven't gotten around to starting the request, because we're still // waiting for the beforeunload handler to finish. We'll pretend that it // did finish, to let the navigation proceed. Note that there's a danger // that the beforeunload handler will later finish and possibly return // false (meaning the navigation should not proceed), but we'll ignore it // in this case because it took too long. - if (pending_render_frame_host_->render_view_host()-> - are_navigations_suspended()) { - pending_render_frame_host_->render_view_host()->SetNavigationsSuspended( + if (pending_render_view_host_->are_navigations_suspended()) + pending_render_view_host_->SetNavigationsSuspended( false, base::TimeTicks::Now()); - } } return false; } -// TODO(creis): This should take in a RenderFrameHost. void RenderFrameHostManager::SwappedOut(RenderViewHost* render_view_host) { // Make sure this is from our current RVH, and that we have a pending // navigation from OnCrossSiteResponse. (There may be no pending navigation // for data URLs that don't make network requests, for example.) If not, // just return early and ignore. - if (render_view_host != render_frame_host_->render_view_host() || - !pending_nav_params_.get()) { + if (render_view_host != render_view_host_ || !pending_nav_params_.get()) { pending_nav_params_.reset(); return; } @@ -291,24 +275,23 @@ void RenderFrameHostManager::SwappedOut(RenderViewHost* render_view_host) { pending_nav_params_->global_request_id, pending_nav_params_->should_replace_current_entry, true); - } else if (pending_render_frame_host_) { + } else if (pending_render_view_host_) { RenderProcessHostImpl* pending_process = static_cast<RenderProcessHostImpl*>( - pending_render_frame_host_->GetProcess()); + pending_render_view_host_->GetProcess()); pending_process->ResumeDeferredNavigation( pending_nav_params_->global_request_id); } pending_nav_params_.reset(); } -// TODO(creis): This should take in a RenderFrameHost. void RenderFrameHostManager::DidNavigateMainFrame( RenderViewHost* render_view_host) { if (!cross_navigation_pending_) { - DCHECK(!pending_render_frame_host_); + DCHECK(!pending_render_view_host_); // We should only hear this from our current renderer. - DCHECK(render_view_host == render_frame_host_->render_view_host()); + DCHECK(render_view_host == render_view_host_); // Even when there is no pending RVH, there may be a pending Web UI. if (pending_web_ui()) @@ -316,18 +299,17 @@ void RenderFrameHostManager::DidNavigateMainFrame( return; } - if (render_view_host == pending_render_frame_host_->render_view_host()) { + if (render_view_host == pending_render_view_host_) { // The pending cross-site navigation completed, so show the renderer. // If it committed without sending network requests (e.g., data URLs), - // then we still need to swap out the old RFH first and run its unload + // then we still need to swap out the old RVH first and run its unload // handler. OK for that to happen in the background. - if (pending_render_frame_host_->render_view_host()-> - HasPendingCrossSiteRequest()) + if (pending_render_view_host_->HasPendingCrossSiteRequest()) SwapOutOldPage(); CommitPending(); cross_navigation_pending_ = false; - } else if (render_view_host == render_frame_host_->render_view_host()) { + } else if (render_view_host == render_view_host_) { // A navigation in the original page has taken place. Cancel the pending // one. CancelPending(); @@ -338,15 +320,14 @@ void RenderFrameHostManager::DidNavigateMainFrame( } } -// TODO(creis): Take in RenderFrameHost instead, since frames can have openers. void RenderFrameHostManager::DidDisownOpener(RenderViewHost* render_view_host) { // Notify all swapped out hosts, including the pending RVH. - for (RenderFrameHostMap::iterator iter = swapped_out_hosts_.begin(); + for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin(); iter != swapped_out_hosts_.end(); ++iter) { - DCHECK_NE(iter->second->render_view_host()->GetSiteInstance(), + DCHECK_NE(iter->second->GetSiteInstance(), current_host()->GetSiteInstance()); - iter->second->render_view_host()->DisownOpener(); + iter->second->DisownOpener(); } } @@ -370,7 +351,7 @@ void RenderFrameHostManager::RendererProcessClosing( // swap them back in while the process is exiting. Start by finding them, // since there could be more than one. std::list<int> ids_to_remove; - for (RenderFrameHostMap::iterator iter = swapped_out_hosts_.begin(); + for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin(); iter != swapped_out_hosts_.end(); ++iter) { if (iter->second->GetProcess() == render_process_host) @@ -379,7 +360,7 @@ void RenderFrameHostManager::RendererProcessClosing( // Now delete them. while (!ids_to_remove.empty()) { - delete swapped_out_hosts_[ids_to_remove.back()]; + swapped_out_hosts_[ids_to_remove.back()]->Shutdown(); swapped_out_hosts_.erase(ids_to_remove.back()); ids_to_remove.pop_back(); } @@ -400,11 +381,9 @@ void RenderFrameHostManager::ShouldClosePage( // might be because the renderer was deemed unresponsive and this call was // already made by ShouldCloseTabOnUnresponsiveRenderer. In that case, it // is ok to do nothing here. - if (pending_render_frame_host_ && - pending_render_frame_host_->render_view_host()-> - are_navigations_suspended()) { - pending_render_frame_host_->render_view_host()-> - SetNavigationsSuspended(false, proceed_time); + if (pending_render_view_host_ && + pending_render_view_host_->are_navigations_suspended()) { + pending_render_view_host_->SetNavigationsSuspended(false, proceed_time); } } else { // Current page says to cancel. @@ -418,21 +397,20 @@ void RenderFrameHostManager::ShouldClosePage( &proceed_to_fire_unload); if (proceed_to_fire_unload) { - // If we're about to close the tab and there's a pending RFH, cancel it. - // Otherwise, if the navigation in the pending RFH completes before the - // close in the current RFH, we'll lose the tab close. - if (pending_render_frame_host_) { + // If we're about to close the tab and there's a pending RVH, cancel it. + // Otherwise, if the navigation in the pending RVH completes before the + // close in the current RVH, we'll lose the tab close. + if (pending_render_view_host_) { CancelPending(); cross_navigation_pending_ = false; } // This is not a cross-site navigation, the tab is being closed. - render_frame_host_->render_view_host()->ClosePage(); + render_view_host_->ClosePage(); } } } -// TODO(creis): Take in a RenderFrameHost from CSRH. void RenderFrameHostManager::OnCrossSiteResponse( RenderViewHost* pending_render_view_host, const GlobalRequestID& global_request_id, @@ -444,9 +422,9 @@ void RenderFrameHostManager::OnCrossSiteResponse( bool should_replace_current_entry) { // This should be called either when the pending RVH is ready to commit or // when we realize that the current RVH's request requires a transfer. - DCHECK(pending_render_view_host == render_frame_host_->render_view_host() || - pending_render_view_host == - pending_render_frame_host_->render_view_host()); + DCHECK( + pending_render_view_host == pending_render_view_host_ || + pending_render_view_host == render_view_host_); // TODO(creis): Eventually we will want to check all navigation responses // here, but currently we pass information for a transfer if @@ -468,7 +446,7 @@ void RenderFrameHostManager::SwapOutOldPage() { // Tell the renderer to suppress any further modal dialogs so that we can swap // it out. This must be done before canceling any current dialog, in case // there is a loop creating additional dialogs. - render_frame_host_->render_view_host()->SuppressDialogsUntilSwapOut(); + render_view_host_->SuppressDialogsUntilSwapOut(); // Now close any modal dialogs that would prevent us from swapping out. This // must be done separately from SwapOut, so that the PageGroupLoadDeferrer is @@ -480,18 +458,14 @@ void RenderFrameHostManager::SwapOutOldPage() { // unload handler finishes and the navigation completes, we will send a // message to the ResourceDispatcherHost, allowing the pending RVH's response // to resume. - // TODO(creis): We should do this on the RFH or else we'll swap out the - // top-level page when subframes navigate. - render_frame_host_->render_view_host()->SwapOut(); + render_view_host_->SwapOut(); // ResourceDispatcherHost has told us to run the onunload handler, which // means it is not a download or unsafe page, and we are going to perform the // navigation. Thus, we no longer need to remember that the RenderViewHost // is part of a pending cross-site request. - if (pending_render_frame_host_) { - pending_render_frame_host_->render_view_host()-> - SetHasPendingCrossSiteRequest(false); - } + if (pending_render_view_host_) + pending_render_view_host_->SetHasPendingCrossSiteRequest(false); } void RenderFrameHostManager::Observe( @@ -510,17 +484,6 @@ void RenderFrameHostManager::Observe( } } -bool RenderFrameHostManager::ClearSwappedOutRFHsInSiteInstance( - int32 site_instance_id, - FrameTreeNode* node) { - RenderFrameHostMap::iterator iter = - node->render_manager()->swapped_out_hosts_.find(site_instance_id); - if (iter != node->render_manager()->swapped_out_hosts_.end()) - delete iter->second; - - return true; -} - bool RenderFrameHostManager::ShouldTransitionCrossSite() { // False in the single-process mode, as it makes RVHs to accumulate // in swapped_out_hosts_. @@ -553,7 +516,7 @@ bool RenderFrameHostManager::ShouldSwapBrowsingInstancesForNavigation( const GURL& current_url = (current_entry) ? SiteInstanceImpl::GetEffectiveURL(browser_context, current_entry->GetURL()) : - render_frame_host_->render_view_host()->GetSiteInstance()->GetSiteURL(); + render_view_host_->GetSiteInstance()->GetSiteURL(); const GURL& new_url = SiteInstanceImpl::GetEffectiveURL(browser_context, new_entry->GetURL()); @@ -578,8 +541,7 @@ bool RenderFrameHostManager::ShouldSwapBrowsingInstancesForNavigation( // Check with the content client as well. Important to pass current_url here, // which uses the SiteInstance's site if there is no current_entry. if (GetContentClient()->browser()->ShouldSwapBrowsingInstancesForNavigation( - render_frame_host_->render_view_host()->GetSiteInstance(), - current_url, new_url)) { + render_view_host_->GetSiteInstance(), current_url, new_url)) { return true; } @@ -759,38 +721,7 @@ SiteInstance* RenderFrameHostManager::GetSiteInstanceForEntry( return current_instance->GetRelatedSiteInstance(dest_url); } -RenderFrameHostImpl* RenderFrameHostManager::CreateRenderFrameHost( - SiteInstance* site_instance, - int view_routing_id, - int frame_routing_id, - bool swapped_out, - bool hidden) { - if (frame_routing_id == MSG_ROUTING_NONE) - frame_routing_id = site_instance->GetProcess()->GetNextRoutingID(); - - // Create a RVH for main frames, or find the existing one for subframes. - FrameTree* frame_tree = frame_tree_node_->frame_tree(); - RenderViewHostImpl* render_view_host = NULL; - if (frame_tree_node_->IsMainFrame()) { - render_view_host = frame_tree->CreateRenderViewHostForMainFrame( - site_instance, view_routing_id, frame_routing_id, swapped_out, hidden); - } else { - render_view_host = frame_tree->GetRenderViewHostForSubFrame(site_instance); - } - - // TODO(creis): Make render_frame_host a scoped_ptr. - // TODO(creis): Pass hidden to RFH. - RenderFrameHostImpl* render_frame_host = - RenderFrameHostFactory::Create(render_view_host, - render_frame_delegate_, - frame_tree, - frame_tree_node_, - frame_routing_id, - swapped_out).release(); - return render_frame_host; -} - -int RenderFrameHostManager::CreateRenderFrame( +int RenderFrameHostManager::CreateRenderView( SiteInstance* instance, int opener_route_id, bool swapped_out, @@ -798,61 +729,59 @@ int RenderFrameHostManager::CreateRenderFrame( CHECK(instance); DCHECK(!swapped_out || hidden); // Swapped out views should always be hidden. - // We are creating a pending or swapped out RFH here. We should never create - // it in the same SiteInstance as our current RFH. - CHECK_NE(render_frame_host_->render_view_host()->GetSiteInstance(), instance); + // We are creating a pending or swapped out RVH here. We should never create + // it in the same SiteInstance as our current RVH. + CHECK_NE(render_view_host_->GetSiteInstance(), instance); - // Check if we've already created an RFH for this SiteInstance. If so, try + // Check if we've already created an RVH for this SiteInstance. If so, try // to re-use the existing one, which has already been initialized. We'll // remove it from the list of swapped out hosts if it commits. - RenderFrameHostImpl* new_render_frame_host = - GetSwappedOutRenderFrameHost(instance); - if (new_render_frame_host) { + RenderViewHostImpl* new_render_view_host = static_cast<RenderViewHostImpl*>( + GetSwappedOutRenderViewHost(instance)); + if (new_render_view_host) { // Prevent the process from exiting while we're trying to use it. if (!swapped_out) - new_render_frame_host->GetProcess()->AddPendingView(); + new_render_view_host->GetProcess()->AddPendingView(); } else { - // Create a new RenderFrameHost if we don't find an existing one. - // TODO(creis): Make new_render_frame_host a scoped_ptr. - new_render_frame_host = CreateRenderFrameHost(instance, MSG_ROUTING_NONE, - MSG_ROUTING_NONE, swapped_out, - hidden); - - // If the new RFH is swapped out already, store it. Otherwise prevent the + // Create a new RenderViewHost if we don't find an existing one. + new_render_view_host = static_cast<RenderViewHostImpl*>( + RenderViewHostFactory::Create(instance, + render_view_delegate_, + render_frame_delegate_, + render_widget_delegate_, + MSG_ROUTING_NONE, + MSG_ROUTING_NONE, + swapped_out, + hidden)); + + // If the new RVH is swapped out already, store it. Otherwise prevent the // process from exiting while we're trying to navigate in it. if (swapped_out) { - swapped_out_hosts_[instance->GetId()] = new_render_frame_host; + swapped_out_hosts_[instance->GetId()] = new_render_view_host; } else { - new_render_frame_host->GetProcess()->AddPendingView(); + new_render_view_host->GetProcess()->AddPendingView(); } - RenderViewHostImpl* render_view_host = - new_render_frame_host->render_view_host(); - bool success = InitRenderView(render_view_host, opener_route_id); - if (success && frame_tree_node_->IsMainFrame()) { - // Don't show the main frame's view until we get a DidNavigate from it. - render_view_host->GetView()->Hide(); + bool success = InitRenderView(new_render_view_host, opener_route_id); + if (success) { + // Don't show the view until we get a DidNavigate from it. + new_render_view_host->GetView()->Hide(); } else if (!swapped_out) { CancelPending(); } } - // Use this as our new pending RFH if it isn't swapped out. + // Use this as our new pending RVH if it isn't swapped out. if (!swapped_out) - pending_render_frame_host_ = new_render_frame_host; + pending_render_view_host_ = new_render_view_host; - return new_render_frame_host->render_view_host()->GetRoutingID(); + return new_render_view_host->GetRoutingID(); } bool RenderFrameHostManager::InitRenderView(RenderViewHost* render_view_host, int opener_route_id) { - // We may have initialized this RenderViewHost for another RenderFrameHost. - if (render_view_host->IsRenderViewLive()) - return true; - // If the pending navigation is to a WebUI and the RenderView is not in a - // guest process, tell the RenderViewHost about any bindings it will need - // enabled. + // guest process, tell the RenderView about any bindings it will need enabled. if (pending_web_ui() && !render_view_host->GetProcess()->IsGuest()) { render_view_host->AllowBindings(pending_web_ui()->GetBindings()); } else { @@ -893,10 +822,10 @@ void RenderFrameHostManager::CommitPending() { else if (!pending_and_current_web_ui_.get()) web_ui_.reset(); - // It's possible for the pending_render_frame_host_ to be NULL when we aren't + // It's possible for the pending_render_view_host_ to be NULL when we aren't // crossing process boundaries. If so, we just needed to handle the Web UI // committing above and we're done. - if (!pending_render_frame_host_) { + if (!pending_render_view_host_) { if (will_focus_location_bar) delegate_->SetFocusToLocationBar(false); return; @@ -905,110 +834,89 @@ void RenderFrameHostManager::CommitPending() { // Remember if the page was focused so we can focus the new renderer in // that case. bool focus_render_view = !will_focus_location_bar && - render_frame_host_->render_view_host()->GetView() && - render_frame_host_->render_view_host()->GetView()->HasFocus(); + render_view_host_->GetView() && render_view_host_->GetView()->HasFocus(); - // Swap in the pending frame and make it active. Also ensure the FrameTree + // Swap in the pending view and make it active. Also ensure the FrameTree // stays in sync. - RenderFrameHostImpl* old_render_frame_host = render_frame_host_; - render_frame_host_ = pending_render_frame_host_; - pending_render_frame_host_ = NULL; - render_frame_host_->render_view_host()->AttachToFrameTree(); + RenderViewHostImpl* old_render_view_host = render_view_host_; + render_view_host_ = pending_render_view_host_; + pending_render_view_host_ = NULL; + render_view_host_->AttachToFrameTree(); // The process will no longer try to exit, so we can decrement the count. - render_frame_host_->GetProcess()->RemovePendingView(); - - // TODO(creis): As long as show/hide are on RVH, we don't want to do them for - // subframe navigations or they'll interfere with the top-level page. - bool is_main_frame = frame_tree_node_->IsMainFrame(); + render_view_host_->GetProcess()->RemovePendingView(); // If the view is gone, then this RenderViewHost died while it was hidden. // We ignored the RenderProcessGone call at the time, so we should send it now // to make sure the sad tab shows up, etc. - if (!render_frame_host_->render_view_host()->GetView()) { - delegate_->RenderProcessGoneFromRenderManager( - render_frame_host_->render_view_host()); - } else if (!delegate_->IsHidden() && is_main_frame) { - render_frame_host_->render_view_host()->GetView()->Show(); - } + if (!render_view_host_->GetView()) + delegate_->RenderProcessGoneFromRenderManager(render_view_host_); + else if (!delegate_->IsHidden()) + render_view_host_->GetView()->Show(); // Hide the old view now that the new one is visible. - if (old_render_frame_host->render_view_host()->GetView()) { - old_render_frame_host->render_view_host()->GetView()->Hide(); - old_render_frame_host->render_view_host()->WasSwappedOut(); + if (old_render_view_host->GetView()) { + old_render_view_host->GetView()->Hide(); + old_render_view_host->WasSwappedOut(); } // Make sure the size is up to date. (Fix for bug 1079768.) delegate_->UpdateRenderViewSizeForRenderManager(); - if (will_focus_location_bar) { + if (will_focus_location_bar) delegate_->SetFocusToLocationBar(false); - } else if (focus_render_view && - render_frame_host_->render_view_host()->GetView()) { - RenderWidgetHostViewPort::FromRWHV( - render_frame_host_->render_view_host()->GetView())->Focus(); - } - - // Notify that we've swapped RenderFrameHosts. We do this before shutting down - // the RFH so that we can clean up RendererResources related to the RFH first. - // TODO(creis): Only do this on top-level RFHs for now, and later update it to - // pass the RFHs. - if (is_main_frame) { - delegate_->NotifySwappedFromRenderManager( - old_render_frame_host->render_view_host(), - render_frame_host_->render_view_host()); - } - - // If the pending frame was on the swapped out list, we can remove it. - swapped_out_hosts_.erase(render_frame_host_->render_view_host()-> - GetSiteInstance()->GetId()); - - if (old_render_frame_host->render_view_host()->IsRenderViewLive()) { - // If the old RFH is live, we are swapping it out and should keep track of + else if (focus_render_view && render_view_host_->GetView()) + RenderWidgetHostViewPort::FromRWHV(render_view_host_->GetView())->Focus(); + + // Notify that we've swapped RenderViewHosts. We do this + // before shutting down the RVH so that we can clean up + // RendererResources related to the RVH first. + delegate_->NotifySwappedFromRenderManager(old_render_view_host, + render_view_host_); + + // If the pending view was on the swapped out list, we can remove it. + swapped_out_hosts_.erase(render_view_host_->GetSiteInstance()->GetId()); + + // If there are no active RVHs in this SiteInstance, it means that + // this RVH was the last active one in the SiteInstance. Now that we + // know that all RVHs are swapped out, we can delete all the RVHs in + // this SiteInstance. + if (!static_cast<SiteInstanceImpl*>(old_render_view_host->GetSiteInstance())-> + active_view_count()) { + ShutdownRenderViewHostsInSiteInstance( + old_render_view_host->GetSiteInstance()->GetId()); + // This is deleted while cleaning up the SitaInstance's views. + old_render_view_host = NULL; + } else if (old_render_view_host->IsRenderViewLive()) { + // If the old RVH is live, we are swapping it out and should keep track of // it in case we navigate back to it. - DCHECK(old_render_frame_host->render_view_host()->is_swapped_out()); + DCHECK(old_render_view_host->is_swapped_out()); // Temp fix for http://crbug.com/90867 until we do a better cleanup to make // sure we don't get different rvh instances for the same site instance // in the same rvhmgr. // TODO(creis): Clean this up. int32 old_site_instance_id = - old_render_frame_host->render_view_host()->GetSiteInstance()->GetId(); - RenderFrameHostMap::iterator iter = + old_render_view_host->GetSiteInstance()->GetId(); + RenderViewHostMap::iterator iter = swapped_out_hosts_.find(old_site_instance_id); if (iter != swapped_out_hosts_.end() && - iter->second != old_render_frame_host) { - // Delete the RFH that will be replaced in the map to avoid a leak. - delete iter->second; - } - swapped_out_hosts_[old_site_instance_id] = old_render_frame_host; - - // If there are no active views in this SiteInstance, it means that - // this RFH was the last active one in the SiteInstance. Now that we - // know that all RFHs are swapped out, we can delete all the RFHs and RVHs - // in this SiteInstance. We do this after ensuring the RFH is on the - // swapped out list to simplify the deletion. - if (!static_cast<SiteInstanceImpl*>( - old_render_frame_host->render_view_host()->GetSiteInstance())-> - active_view_count()) { - ShutdownRenderFrameHostsInSiteInstance(old_site_instance_id); - // This is deleted while cleaning up the SiteInstance's views. - old_render_frame_host = NULL; + iter->second != old_render_view_host) { + // Shutdown the RVH that will be replaced in the map to avoid a leak. + iter->second->Shutdown(); } + swapped_out_hosts_[old_site_instance_id] = old_render_view_host; } else { - delete old_render_frame_host; + old_render_view_host->Shutdown(); + old_render_view_host = NULL; // Shutdown() deletes it. } } -void RenderFrameHostManager::ShutdownRenderFrameHostsInSiteInstance( +void RenderFrameHostManager::ShutdownRenderViewHostsInSiteInstance( int32 site_instance_id) { - // First remove any swapped out RFH for this SiteInstance from our own list. - ClearSwappedOutRFHsInSiteInstance(site_instance_id, frame_tree_node_); - - // Use the safe RenderWidgetHost iterator for now to find all RenderViewHosts - // in the SiteInstance, then tell their respective FrameTrees to remove all - // swapped out RenderFrameHosts corresponding to them. - // TODO(creis): Replace this with a RenderFrameHostIterator that protects - // against use-after-frees if a later element is deleted before getting to it. + // First remove any swapped out RVH for this SiteInstance from our + // list. + swapped_out_hosts_.erase(site_instance_id); + scoped_ptr<RenderWidgetHostIterator> widgets( RenderWidgetHostImpl::GetAllRenderWidgetHosts()); while (RenderWidgetHost* widget = widgets->GetNextHost()) { @@ -1016,33 +924,25 @@ void RenderFrameHostManager::ShutdownRenderFrameHostsInSiteInstance( continue; RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(RenderViewHost::From(widget)); - if (site_instance_id == rvh->GetSiteInstance()->GetId()) { - // This deletes all RenderFrameHosts using the |rvh|, which then causes - // |rvh| to Shutdown. - FrameTree* tree = rvh->GetDelegate()->GetFrameTree(); - tree->ForEach(base::Bind( - &RenderFrameHostManager::ClearSwappedOutRFHsInSiteInstance, - site_instance_id)); - // rvh is now deleted. - } + if (site_instance_id == rvh->GetSiteInstance()->GetId()) + rvh->Shutdown(); } } -RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( +RenderViewHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( const NavigationEntryImpl& entry) { // If we are currently navigating cross-process, we want to get back to normal // and then navigate as usual. if (cross_navigation_pending_) { - if (pending_render_frame_host_) + if (pending_render_view_host_) CancelPending(); cross_navigation_pending_ = false; } - // render_frame_host_'s SiteInstance and new_instance will not be deleted + // render_view_host_'s SiteInstance and new_instance will not be deleted // before the end of this method, so we don't have to worry about their ref // counts dropping to zero. - SiteInstance* current_instance = - render_frame_host_->render_view_host()->GetSiteInstance(); + SiteInstance* current_instance = render_view_host_->GetSiteInstance(); SiteInstance* new_instance = current_instance; // We do not currently swap processes for navigations in webview tag guests. @@ -1050,7 +950,7 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( // Determine if we need a new BrowsingInstance for this entry. If true, this // implies that it will get a new SiteInstance (and likely process), and that - // other tabs in the current BrowsingInstance will be unable to script it. + // other tabs in the current BrosingInstance will be unalbe to script it. // This is used for cases that require a process swap even in the // process-per-tab model, such as WebUI pages. const NavigationEntry* current_entry = @@ -1061,13 +961,13 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( new_instance = GetSiteInstanceForEntry(entry, current_instance, force_swap); // If force_swap is true, we must use a different SiteInstance. If we didn't, - // we would have two RenderFrameHosts in the same SiteInstance and the same - // frame, resulting in page_id conflicts for their NavigationEntries. + // we would have two RenderViewHosts in the same SiteInstance and the same + // tab, resulting in page_id conflicts for their NavigationEntries. if (force_swap) CHECK_NE(new_instance, current_instance); if (new_instance != current_instance) { - // New SiteInstance: create a pending RFH to navigate. + // New SiteInstance: create a pending RVH to navigate. DCHECK(!cross_navigation_pending_); // This will possibly create (set to NULL) a Web UI object for the pending @@ -1078,8 +978,8 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( // not have its bindings set appropriately. SetPendingWebUI(entry); - // Ensure that we have created RFHs for the new RFH's opener chain if - // we are staying in the same BrowsingInstance. This allows the pending RFH + // Ensure that we have created RVHs for the new RVH's opener chain if + // we are staying in the same BrowsingInstance. This allows the pending RVH // to send cross-process script calls to its opener(s). int opener_route_id = MSG_ROUTING_NONE; if (new_instance->IsRelatedSiteInstance(current_instance)) { @@ -1087,26 +987,26 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( delegate_->CreateOpenerRenderViewsForRenderManager(new_instance); } - // Create a non-swapped-out pending RFH with the given opener and navigate + // Create a non-swapped-out pending RVH with the given opener and navigate // it. - int route_id = CreateRenderFrame(new_instance, opener_route_id, false, - delegate_->IsHidden()); + int route_id = CreateRenderView(new_instance, opener_route_id, false, + delegate_->IsHidden()); if (route_id == MSG_ROUTING_NONE) return NULL; - // Check if our current RFH is live before we set up a transition. - if (!render_frame_host_->render_view_host()->IsRenderViewLive()) { + // Check if our current RVH is live before we set up a transition. + if (!render_view_host_->IsRenderViewLive()) { if (!cross_navigation_pending_) { - // The current RFH is not live. There's no reason to sit around with a - // sad tab or a newly created RFH while we wait for the pending RFH to - // navigate. Just switch to the pending RFH now and go back to non + // The current RVH is not live. There's no reason to sit around with a + // sad tab or a newly created RVH while we wait for the pending RVH to + // navigate. Just switch to the pending RVH now and go back to non // cross-navigating (Note that we don't care about on{before}unload - // handlers if the current RFH isn't live.) + // handlers if the current RVH isn't live.) CommitPending(); - return render_frame_host_; + return render_view_host_; } else { NOTREACHED(); - return render_frame_host_; + return render_view_host_; } } // Otherwise, it's safe to treat this as a pending cross-site transition. @@ -1117,8 +1017,7 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( // Navigate message) until we hear back from the old renderer's // beforeunload handler. If the handler returns false, we'll have to // cancel the request. - DCHECK(!pending_render_frame_host_->render_view_host()-> - are_navigations_suspended()); + DCHECK(!pending_render_view_host_->are_navigations_suspended()); bool is_transfer = entry.transferred_global_request_id() != GlobalRequestID(); if (is_transfer) { @@ -1130,21 +1029,19 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( // Also make sure the old render view stops, in case a load is in // progress. (We don't want to do this for transfers, since it will // interrupt the transfer with an unexpected DidStopLoading.) - render_frame_host_->render_view_host()->Send(new ViewMsg_Stop( - render_frame_host_->render_view_host()->GetRoutingID())); + render_view_host_->Send( + new ViewMsg_Stop(render_view_host_->GetRoutingID())); - pending_render_frame_host_->render_view_host()->SetNavigationsSuspended( - true, base::TimeTicks()); + pending_render_view_host_->SetNavigationsSuspended(true, + base::TimeTicks()); // Tell the CrossSiteRequestManager that this RVH has a pending cross-site // request, so that ResourceDispatcherHost will know to tell us to run the // old page's unload handler before it sends the response. - // TODO(creis): This needs to be on the RFH. - pending_render_frame_host_->render_view_host()-> - SetHasPendingCrossSiteRequest(true); + pending_render_view_host_->SetHasPendingCrossSiteRequest(true); } - // We now have a pending RFH. + // We now have a pending RVH. DCHECK(!cross_navigation_pending_); cross_navigation_pending_ = true; @@ -1153,12 +1050,12 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( // doesn't otherwise know that the cross-site request is happening. This // will trigger a call to ShouldClosePage with the reply. if (!is_transfer) - render_frame_host_->render_view_host()->FirePageBeforeUnload(true); + render_view_host_->FirePageBeforeUnload(true); - return pending_render_frame_host_; + return pending_render_view_host_; } - // Otherwise the same SiteInstance can be used. Navigate render_frame_host_. + // Otherwise the same SiteInstance can be used. Navigate render_view_host_. DCHECK(!cross_navigation_pending_); if (ShouldReuseWebUI(current_entry, &entry)) { pending_web_ui_.reset(); @@ -1167,53 +1064,46 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate( SetPendingWebUI(entry); // Make sure the new RenderViewHost has the right bindings. - if (pending_web_ui() && !render_frame_host_->GetProcess()->IsGuest()) { - render_frame_host_->render_view_host()->AllowBindings( - pending_web_ui()->GetBindings()); - } + if (pending_web_ui() && !render_view_host_->GetProcess()->IsGuest()) + render_view_host_->AllowBindings(pending_web_ui()->GetBindings()); } - if (pending_web_ui() && - render_frame_host_->render_view_host()->IsRenderViewLive()) { - pending_web_ui()->GetController()->RenderViewReused( - render_frame_host_->render_view_host()); - } + if (pending_web_ui() && render_view_host_->IsRenderViewLive()) + pending_web_ui()->GetController()->RenderViewReused(render_view_host_); // The renderer can exit view source mode when any error or cancellation // happen. We must overwrite to recover the mode. if (entry.IsViewSourceMode()) { - render_frame_host_->render_view_host()->Send( - new ViewMsg_EnableViewSourceMode( - render_frame_host_->render_view_host()->GetRoutingID())); + render_view_host_->Send( + new ViewMsg_EnableViewSourceMode(render_view_host_->GetRoutingID())); } - return render_frame_host_; + return render_view_host_; } void RenderFrameHostManager::CancelPending() { - RenderFrameHostImpl* pending_render_frame_host = pending_render_frame_host_; - pending_render_frame_host_ = NULL; + RenderViewHostImpl* pending_render_view_host = pending_render_view_host_; + pending_render_view_host_ = NULL; RenderViewDevToolsAgentHost::OnCancelPendingNavigation( - pending_render_frame_host->render_view_host(), - render_frame_host_->render_view_host()); + pending_render_view_host, + render_view_host_); // We no longer need to prevent the process from exiting. - pending_render_frame_host->GetProcess()->RemovePendingView(); + pending_render_view_host->GetProcess()->RemovePendingView(); - // The pending RFH may already be on the swapped out list if we started to + // The pending RVH may already be on the swapped out list if we started to // swap it back in and then canceled. If so, make sure it gets swapped out // again. If it's not on the swapped out list (e.g., aborting a pending // load), then it's safe to shut down. - if (IsOnSwappedOutList(pending_render_frame_host)) { + if (IsOnSwappedOutList(pending_render_view_host)) { // Any currently suspended navigations are no longer needed. - pending_render_frame_host->render_view_host()->CancelSuspendedNavigations(); + pending_render_view_host->CancelSuspendedNavigations(); - // TODO(creis): We need to swap out the RFH. - pending_render_frame_host->render_view_host()->SwapOut(); + pending_render_view_host->SwapOut(); } else { // We won't be coming back, so shut this one down. - delete pending_render_frame_host; + pending_render_view_host->Shutdown(); } pending_web_ui_.reset(); @@ -1222,69 +1112,47 @@ void RenderFrameHostManager::CancelPending() { void RenderFrameHostManager::RenderViewDeleted(RenderViewHost* rvh) { // We are doing this in order to work around and to track a crasher - // (http://crbug.com/23411) where it seems that pending_render_frame_host_ is + // (http://crbug.com/23411) where it seems that pending_render_view_host_ is // deleted (not sure from where) but not NULLed. - if (pending_render_frame_host_ && - rvh == pending_render_frame_host_->render_view_host()) { + if (rvh == pending_render_view_host_) { // If you hit this NOTREACHED, please report it in the following bug // http://crbug.com/23411 Make sure to include what you were doing when it // happened (navigating to a new page, closing a tab...) and if you can // reproduce. NOTREACHED(); - pending_render_frame_host_ = NULL; + pending_render_view_host_ = NULL; } // Make sure deleted RVHs are not kept in the swapped out list while we are - // still alive. (If render_frame_host_ is null, we're already being deleted.) - if (!render_frame_host_) + // still alive. (If render_view_host_ is null, we're already being deleted.) + if (!render_view_host_) return; - // We can't look it up by SiteInstance ID, which may no longer be valid. - for (RenderFrameHostMap::iterator iter = swapped_out_hosts_.begin(); + for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin(); iter != swapped_out_hosts_.end(); ++iter) { - if (iter->second->render_view_host() == rvh) { + if (iter->second == rvh) { swapped_out_hosts_.erase(iter); break; } } } -bool RenderFrameHostManager::IsRVHOnSwappedOutList( - RenderViewHostImpl* rvh) const { - RenderFrameHostImpl* render_frame_host = GetSwappedOutRenderFrameHost( - rvh->GetSiteInstance()); - if (!render_frame_host) +bool RenderFrameHostManager::IsOnSwappedOutList(RenderViewHost* rvh) const { + if (!rvh->GetSiteInstance()) return false; - return IsOnSwappedOutList(render_frame_host); -} -bool RenderFrameHostManager::IsOnSwappedOutList( - RenderFrameHostImpl* rfh) const { - if (!rfh->render_view_host()->GetSiteInstance()) - return false; - - RenderFrameHostMap::const_iterator iter = swapped_out_hosts_.find( - rfh->render_view_host()->GetSiteInstance()->GetId()); + RenderViewHostMap::const_iterator iter = swapped_out_hosts_.find( + rvh->GetSiteInstance()->GetId()); if (iter == swapped_out_hosts_.end()) return false; - return iter->second == rfh; + return iter->second == rvh; } RenderViewHostImpl* RenderFrameHostManager::GetSwappedOutRenderViewHost( - SiteInstance* instance) const { - RenderFrameHostImpl* render_frame_host = - GetSwappedOutRenderFrameHost(instance); - if (render_frame_host) - return render_frame_host->render_view_host(); - return NULL; -} - -RenderFrameHostImpl* RenderFrameHostManager::GetSwappedOutRenderFrameHost( - SiteInstance* instance) const { - RenderFrameHostMap::const_iterator iter = - swapped_out_hosts_.find(instance->GetId()); + SiteInstance* instance) { + RenderViewHostMap::iterator iter = swapped_out_hosts_.find(instance->GetId()); if (iter != swapped_out_hosts_.end()) return iter->second; |