| // Copyright 2013 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/frame_host/render_frame_host_manager.h" |
| |
| #include <utility> |
| |
| #include "base/command_line.h" |
| #include "base/logging.h" |
| #include "base/stl_util.h" |
| #include "base/trace_event/trace_event.h" |
| #include "content/browser/child_process_security_policy_impl.h" |
| #include "content/browser/devtools/render_frame_devtools_agent_host.h" |
| #include "content/browser/frame_host/cross_site_transferring_request.h" |
| #include "content/browser/frame_host/debug_urls.h" |
| #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/navigation_request.h" |
| #include "content/browser/frame_host/navigator.h" |
| #include "content/browser/frame_host/render_frame_host_factory.h" |
| #include "content/browser/frame_host/render_frame_host_impl.h" |
| #include "content/browser/frame_host/render_frame_proxy_host.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" |
| #include "content/browser/site_instance_impl.h" |
| #include "content/browser/webui/web_ui_controller_factory_registry.h" |
| #include "content/browser/webui/web_ui_impl.h" |
| #include "content/common/frame_messages.h" |
| #include "content/common/view_messages.h" |
| #include "content/public/browser/content_browser_client.h" |
| #include "content/public/browser/notification_service.h" |
| #include "content/public/browser/notification_types.h" |
| #include "content/public/browser/render_widget_host_iterator.h" |
| #include "content/public/browser/render_widget_host_view.h" |
| #include "content/public/browser/user_metrics.h" |
| #include "content/public/browser/web_ui_controller.h" |
| #include "content/public/common/content_switches.h" |
| #include "content/public/common/referrer.h" |
| #include "content/public/common/url_constants.h" |
| |
| namespace content { |
| |
| // static |
| bool RenderFrameHostManager::ClearRFHsPendingShutdown(FrameTreeNode* node) { |
| node->render_manager()->pending_delete_hosts_.clear(); |
| return true; |
| } |
| |
| 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), |
| cross_navigation_pending_(false), |
| render_frame_delegate_(render_frame_delegate), |
| render_view_delegate_(render_view_delegate), |
| render_widget_delegate_(render_widget_delegate), |
| interstitial_page_(nullptr), |
| should_reuse_web_ui_(false), |
| weak_factory_(this) { |
| DCHECK(frame_tree_node_); |
| } |
| |
| RenderFrameHostManager::~RenderFrameHostManager() { |
| if (pending_render_frame_host_) |
| UnsetPendingRenderFrameHost(); |
| |
| if (speculative_render_frame_host_) |
| UnsetSpeculativeRenderFrameHost(); |
| |
| if (render_frame_host_ && |
| render_frame_host_->GetSiteInstance()->active_frame_count() <= 1U) { |
| ShutdownRenderFrameProxyHostsInSiteInstance( |
| render_frame_host_->GetSiteInstance()->GetId()); |
| } |
| |
| // Delete any RenderFrameProxyHosts and swapped out RenderFrameHosts. |
| // It is important to delete those prior to deleting the current |
| // RenderFrameHost, since the CrossProcessFrameConnector (owned by |
| // RenderFrameProxyHost) points to the RenderWidgetHostView associated with |
| // the current RenderFrameHost and uses it during its destructor. |
| STLDeleteValues(&proxy_hosts_); |
| |
| // We should always have a current RenderFrameHost except in some tests. |
| SetRenderFrameHost(scoped_ptr<RenderFrameHostImpl>()); |
| } |
| |
| 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. |
| if (!site_instance) |
| site_instance = SiteInstance::Create(browser_context); |
| |
| int flags = delegate_->IsHidden() ? CREATE_RF_HIDDEN : 0; |
| SetRenderFrameHost(CreateRenderFrameHost(site_instance, view_routing_id, |
| frame_routing_id, flags)); |
| |
| // Keep track of renderer processes as they start to shut down or are |
| // crashed/killed. |
| registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED, |
| NotificationService::AllSources()); |
| registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSING, |
| NotificationService::AllSources()); |
| } |
| |
| RenderViewHostImpl* RenderFrameHostManager::current_host() const { |
| if (!render_frame_host_) |
| return NULL; |
| return render_frame_host_->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(); |
| } |
| |
| RenderWidgetHostView* RenderFrameHostManager::GetRenderWidgetHostView() const { |
| if (interstitial_page_) |
| return interstitial_page_->GetView(); |
| if (render_frame_host_) |
| return render_frame_host_->GetView(); |
| return nullptr; |
| } |
| |
| RenderFrameProxyHost* RenderFrameHostManager::GetProxyToParent() { |
| if (frame_tree_node_->IsMainFrame()) |
| return NULL; |
| |
| RenderFrameProxyHostMap::iterator iter = |
| proxy_hosts_.find(frame_tree_node_->parent() |
| ->render_manager() |
| ->current_frame_host() |
| ->GetSiteInstance() |
| ->GetId()); |
| if (iter == proxy_hosts_.end()) |
| return NULL; |
| |
| return iter->second; |
| } |
| |
| void RenderFrameHostManager::SetPendingWebUI(const GURL& url, int bindings) { |
| pending_web_ui_ = CreateWebUI(url, bindings); |
| pending_and_current_web_ui_.reset(); |
| } |
| |
| scoped_ptr<WebUIImpl> RenderFrameHostManager::CreateWebUI(const GURL& url, |
| int bindings) { |
| scoped_ptr<WebUIImpl> new_web_ui(delegate_->CreateWebUIForRenderManager(url)); |
| |
| // If we have assigned (zero or more) bindings to this NavigationEntry in the |
| // past, make sure we're not granting it different bindings than it had |
| // before. If so, note it and don't give it any bindings, to avoid a |
| // potential privilege escalation. |
| if (new_web_ui && bindings != NavigationEntryImpl::kInvalidBindings && |
| new_web_ui->GetBindings() != bindings) { |
| RecordAction(base::UserMetricsAction("ProcessSwapBindingsMismatch_RVHM")); |
| return nullptr; |
| } |
| return new_web_ui.Pass(); |
| } |
| |
| RenderFrameHostImpl* RenderFrameHostManager::Navigate( |
| const NavigationEntryImpl& entry) { |
| TRACE_EVENT1("navigation", "RenderFrameHostManager:Navigate", |
| "FrameTreeNode id", frame_tree_node_->frame_tree_node_id()); |
| // Create a pending RenderFrameHost to use for the navigation. |
| RenderFrameHostImpl* dest_render_frame_host = UpdateStateForNavigate( |
| entry.GetURL(), entry.source_site_instance(), entry.site_instance(), |
| entry.GetTransitionType(), |
| entry.restore_type() != NavigationEntryImpl::RESTORE_NONE, |
| entry.IsViewSourceMode(), entry.transferred_global_request_id(), |
| entry.bindings()); |
| 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 |
| // its first page. (Bug 1145340) |
| if (dest_render_frame_host != render_frame_host_ && |
| !render_frame_host_->IsRenderFrameLive()) { |
| // 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, |
| MSG_ROUTING_NONE, frame_tree_node_->IsMainFrame()); |
| } |
| |
| // If the renderer crashed, then try to create a new one to satisfy this |
| // navigation request. |
| if (!dest_render_frame_host->IsRenderFrameLive()) { |
| // Instruct the destination render frame host to set up a Mojo connection |
| // with the new render frame if necessary. Note that this call needs to |
| // occur before initializing the RenderView; the flow of creating the |
| // RenderView can cause browser-side code to execute that expects the this |
| // RFH's ServiceRegistry to be initialized (e.g., if the site is a WebUI |
| // site that is handled via Mojo, then Mojo WebUI code in //chrome will |
| // add a service to this RFH's ServiceRegistry). |
| dest_render_frame_host->SetUpMojoIfNeeded(); |
| |
| // Recreate the opener chain. |
| int opener_route_id = delegate_->CreateOpenerRenderViewsForRenderManager( |
| dest_render_frame_host->GetSiteInstance()); |
| if (!InitRenderView(dest_render_frame_host->render_view_host(), |
| opener_route_id, |
| MSG_ROUTING_NONE, |
| frame_tree_node_->IsMainFrame())) |
| 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->GetView()) { |
| dest_render_frame_host->GetView()->Hide(); |
| } else { |
| // Notify here as we won't be calling CommitPending (which does the |
| // notify). |
| delegate_->NotifySwappedFromRenderManager( |
| NULL, render_frame_host_.get(), frame_tree_node_->IsMainFrame()); |
| } |
| } |
| |
| // If entry includes the request ID of a request that is being transferred, |
| // the destination render frame will take ownership, so release ownership of |
| // the request. |
| if (cross_site_transferring_request_.get() && |
| cross_site_transferring_request_->request_id() == |
| entry.transferred_global_request_id()) { |
| cross_site_transferring_request_->ReleaseRequest(); |
| } |
| |
| return dest_render_frame_host; |
| } |
| |
| void RenderFrameHostManager::Stop() { |
| render_frame_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_->Send(new FrameMsg_Stop( |
| pending_render_frame_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); |
| } |
| |
| bool RenderFrameHostManager::ShouldCloseTabOnUnresponsiveRenderer() { |
| // If we're waiting for a close ACK, then the tab should close whether there's |
| // a navigation in progress or not. Unfortunately, we also need to check for |
| // cases that we arrive here with no navigation in progress, since there are |
| // some tab closure paths that don't set is_waiting_for_close_ack to true. |
| // TODO(creis): Clean this up in http://crbug.com/418266. |
| if (!cross_navigation_pending_ || |
| render_frame_host_->render_view_host()->is_waiting_for_close_ack()) |
| return true; |
| |
| // We should always have a pending RFH when there's a cross-process navigation |
| // in progress. Sanity check this for http://crbug.com/276333. |
| CHECK(pending_render_frame_host_); |
| |
| // Unload handlers run in the background, so we should never get an |
| // unresponsiveness warning for them. |
| CHECK(!render_frame_host_->IsWaitingForUnloadACK()); |
| |
| // If the tab becomes unresponsive during beforeunload while doing a |
| // cross-site navigation, proceed with the navigation. (This assumes that |
| // the pending RenderFrameHost is still responsive.) |
| if (render_frame_host_->IsWaitingForBeforeUnloadACK()) { |
| // 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_->are_navigations_suspended()) { |
| pending_render_frame_host_->SetNavigationsSuspended( |
| false, base::TimeTicks::Now()); |
| } |
| } |
| return false; |
| } |
| |
| void RenderFrameHostManager::OnBeforeUnloadACK( |
| bool for_cross_site_transition, |
| bool proceed, |
| const base::TimeTicks& proceed_time) { |
| if (for_cross_site_transition) { |
| DCHECK(!base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableBrowserSideNavigation)); |
| // Ignore if we're not in a cross-site navigation. |
| if (!cross_navigation_pending_) |
| return; |
| |
| if (proceed) { |
| // Ok to unload the current page, so proceed with the cross-site |
| // navigation. Note that if navigations are not currently suspended, it |
| // 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_->are_navigations_suspended()) { |
| pending_render_frame_host_->SetNavigationsSuspended(false, |
| proceed_time); |
| } |
| } else { |
| // Current page says to cancel. |
| CancelPending(); |
| cross_navigation_pending_ = false; |
| } |
| } else { |
| // Non-cross site transition means closing the entire tab. |
| bool proceed_to_fire_unload; |
| delegate_->BeforeUnloadFiredFromRenderManager(proceed, proceed_time, |
| &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_) { |
| CancelPending(); |
| cross_navigation_pending_ = false; |
| } |
| |
| // This is not a cross-site navigation, the tab is being closed. |
| render_frame_host_->render_view_host()->ClosePage(); |
| } |
| } |
| } |
| |
| void RenderFrameHostManager::OnCrossSiteResponse( |
| RenderFrameHostImpl* pending_render_frame_host, |
| const GlobalRequestID& global_request_id, |
| scoped_ptr<CrossSiteTransferringRequest> cross_site_transferring_request, |
| const std::vector<GURL>& transfer_url_chain, |
| const Referrer& referrer, |
| ui::PageTransition page_transition, |
| bool should_replace_current_entry) { |
| // We should only get here for transfer navigations. Most cross-process |
| // navigations can just continue and wait to run the unload handler (by |
| // swapping out) when the new navigation commits. |
| CHECK(cross_site_transferring_request.get()); |
| |
| // A transfer should only have come from our pending or current RFH. |
| // TODO(creis): We need to handle the case that the pending RFH has changed |
| // in the mean time, while this was being posted from the IO thread. We |
| // should probably cancel the request in that case. |
| DCHECK(pending_render_frame_host == pending_render_frame_host_ || |
| pending_render_frame_host == render_frame_host_); |
| |
| // Store the transferring request so that we can release it if the transfer |
| // navigation matches. |
| cross_site_transferring_request_ = cross_site_transferring_request.Pass(); |
| |
| // Sanity check that the params are for the correct frame and process. |
| // These should match the RenderFrameHost that made the request. |
| // If it started as a cross-process navigation via OpenURL, this is the |
| // pending one. If it wasn't cross-process until the transfer, this is the |
| // current one. |
| int render_frame_id = pending_render_frame_host_ ? |
| pending_render_frame_host_->GetRoutingID() : |
| render_frame_host_->GetRoutingID(); |
| DCHECK_EQ(render_frame_id, pending_render_frame_host->GetRoutingID()); |
| int process_id = pending_render_frame_host_ ? |
| pending_render_frame_host_->GetProcess()->GetID() : |
| render_frame_host_->GetProcess()->GetID(); |
| DCHECK_EQ(process_id, global_request_id.child_id); |
| |
| // Treat the last URL in the chain as the destination and the remainder as |
| // the redirect chain. |
| CHECK(transfer_url_chain.size()); |
| GURL transfer_url = transfer_url_chain.back(); |
| std::vector<GURL> rest_of_chain = transfer_url_chain; |
| rest_of_chain.pop_back(); |
| |
| // We don't know whether the original request had |user_action| set to true. |
| // However, since we force the navigation to be in the current tab, it |
| // doesn't matter. |
| pending_render_frame_host->frame_tree_node()->navigator()->RequestTransferURL( |
| pending_render_frame_host, transfer_url, nullptr, rest_of_chain, referrer, |
| page_transition, CURRENT_TAB, global_request_id, |
| should_replace_current_entry, true); |
| |
| // The transferring request was only needed during the RequestTransferURL |
| // call, so it is safe to clear at this point. |
| cross_site_transferring_request_.reset(); |
| } |
| |
| void RenderFrameHostManager::OnDeferredAfterResponseStarted( |
| const GlobalRequestID& global_request_id, |
| RenderFrameHostImpl* pending_render_frame_host) { |
| DCHECK(!response_started_id_.get()); |
| |
| response_started_id_.reset(new GlobalRequestID(global_request_id)); |
| } |
| |
| void RenderFrameHostManager::ResumeResponseDeferredAtStart() { |
| DCHECK(response_started_id_.get()); |
| |
| RenderProcessHostImpl* process = |
| static_cast<RenderProcessHostImpl*>(render_frame_host_->GetProcess()); |
| process->ResumeResponseDeferredAtStart(*response_started_id_); |
| |
| render_frame_host_->ClearPendingTransitionRequestData(); |
| |
| response_started_id_.reset(); |
| } |
| |
| void RenderFrameHostManager::ClearNavigationTransitionData() { |
| render_frame_host_->ClearPendingTransitionRequestData(); |
| } |
| |
| void RenderFrameHostManager::DidNavigateFrame( |
| RenderFrameHostImpl* render_frame_host, |
| bool was_caused_by_user_gesture) { |
| if (base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableBrowserSideNavigation)) { |
| if (render_frame_host == speculative_render_frame_host_.get()) { |
| CommitPending(); |
| } else if (render_frame_host == render_frame_host_.get()) { |
| // TODO(carlosk): this code doesn't properly handle in-page navigation or |
| // interwoven navigation requests. |
| DCHECK(!speculative_render_frame_host_); |
| } else { |
| // No one else should be sending us a DidNavigate in this state. |
| DCHECK(false); |
| } |
| DCHECK(!speculative_render_frame_host_); |
| return; |
| } |
| |
| if (!cross_navigation_pending_) { |
| DCHECK(!pending_render_frame_host_); |
| |
| // We should only hear this from our current renderer. |
| DCHECK_EQ(render_frame_host_, render_frame_host); |
| |
| // Even when there is no pending RVH, there may be a pending Web UI. |
| if (pending_web_ui()) |
| CommitPending(); |
| return; |
| } |
| |
| if (render_frame_host == pending_render_frame_host_) { |
| // The pending cross-site navigation completed, so show the renderer. |
| CommitPending(); |
| } else if (render_frame_host == render_frame_host_) { |
| if (was_caused_by_user_gesture) { |
| // A navigation in the original page has taken place. Cancel the pending |
| // one. Only do it for user gesture originated navigations to prevent |
| // page doing any shenanigans to prevent user from navigating. |
| // See https://code.google.com/p/chromium/issues/detail?id=75195 |
| CancelPending(); |
| cross_navigation_pending_ = false; |
| } |
| } else { |
| // No one else should be sending us DidNavigate in this state. |
| DCHECK(false); |
| } |
| } |
| |
| void RenderFrameHostManager::DidDisownOpener( |
| RenderFrameHost* render_frame_host) { |
| // Notify all RenderFrameHosts but the one that notified us. This is necessary |
| // in case a process swap has occurred while the message was in flight. |
| for (RenderFrameProxyHostMap::iterator iter = proxy_hosts_.begin(); |
| iter != proxy_hosts_.end(); |
| ++iter) { |
| DCHECK_NE(iter->second->GetSiteInstance(), |
| current_frame_host()->GetSiteInstance()); |
| iter->second->DisownOpener(); |
| } |
| |
| if (render_frame_host_.get() != render_frame_host) |
| render_frame_host_->DisownOpener(); |
| |
| if (pending_render_frame_host_ && |
| pending_render_frame_host_.get() != render_frame_host) { |
| pending_render_frame_host_->DisownOpener(); |
| } |
| } |
| |
| void RenderFrameHostManager::RendererProcessClosing( |
| RenderProcessHost* render_process_host) { |
| // Remove any swapped out RVHs from this process, so that we don't try to |
| // 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; |
| // Do not remove proxies in the dead process that still have active frame |
| // count though, we just reset them to be uninitialized. |
| std::list<int> ids_to_keep; |
| for (RenderFrameProxyHostMap::iterator iter = proxy_hosts_.begin(); |
| iter != proxy_hosts_.end(); |
| ++iter) { |
| RenderFrameProxyHost* proxy = iter->second; |
| if (proxy->GetProcess() != render_process_host) |
| continue; |
| |
| if (static_cast<SiteInstanceImpl*>(proxy->GetSiteInstance()) |
| ->active_frame_count() >= 1U) { |
| ids_to_keep.push_back(iter->first); |
| } else { |
| ids_to_remove.push_back(iter->first); |
| } |
| } |
| |
| // Now delete them. |
| while (!ids_to_remove.empty()) { |
| delete proxy_hosts_[ids_to_remove.back()]; |
| proxy_hosts_.erase(ids_to_remove.back()); |
| ids_to_remove.pop_back(); |
| } |
| |
| while (!ids_to_keep.empty()) { |
| frame_tree_node_->frame_tree()->ForEach( |
| base::Bind( |
| &RenderFrameHostManager::ResetProxiesInSiteInstance, |
| ids_to_keep.back())); |
| ids_to_keep.pop_back(); |
| } |
| } |
| |
| void RenderFrameHostManager::SwapOutOldFrame( |
| scoped_ptr<RenderFrameHostImpl> old_render_frame_host) { |
| TRACE_EVENT1("navigation", "RenderFrameHostManager::SwapOutOldFrame", |
| "FrameTreeNode id", frame_tree_node_->frame_tree_node_id()); |
| |
| // 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. |
| // TODO(creis): Handle modal dialogs in subframe processes. |
| old_render_frame_host->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 |
| // no longer on the stack when we send the SwapOut message. |
| delegate_->CancelModalDialogsForRenderManager(); |
| |
| // If the old RFH is not live, just return as there is no further work to do. |
| // It will be deleted and there will be no proxy created. |
| int32 old_site_instance_id = |
| old_render_frame_host->GetSiteInstance()->GetId(); |
| if (!old_render_frame_host->IsRenderFrameLive()) { |
| ShutdownRenderFrameProxyHostsInSiteInstance(old_site_instance_id); |
| return; |
| } |
| |
| // If there are no active frames besides this one, we can delete the old |
| // RenderFrameHost once it runs its unload handler, without replacing it with |
| // a proxy. |
| size_t active_frame_count = |
| old_render_frame_host->GetSiteInstance()->active_frame_count(); |
| if (active_frame_count <= 1) { |
| // Tell the old RenderFrameHost to swap out, with no proxy to replace it. |
| old_render_frame_host->SwapOut(NULL, true); |
| MoveToPendingDeleteHosts(old_render_frame_host.Pass()); |
| |
| // Also clear out any proxies from this SiteInstance, in case this was the |
| // last one keeping other proxies alive. |
| ShutdownRenderFrameProxyHostsInSiteInstance(old_site_instance_id); |
| |
| return; |
| } |
| |
| // Otherwise there are active views and we need a proxy for the old RFH. |
| // (There should not be one yet.) |
| CHECK(!GetRenderFrameProxyHost(old_render_frame_host->GetSiteInstance())); |
| RenderFrameProxyHost* proxy = new RenderFrameProxyHost( |
| old_render_frame_host->GetSiteInstance(), frame_tree_node_); |
| CHECK(proxy_hosts_.insert(std::make_pair(old_site_instance_id, proxy)).second) |
| << "Inserting a duplicate item."; |
| |
| // Tell the old RenderFrameHost to swap out and be replaced by the proxy. |
| old_render_frame_host->SwapOut(proxy, true); |
| |
| // SwapOut creates a RenderFrameProxy, so set the proxy to be initialized. |
| proxy->set_render_frame_proxy_created(true); |
| |
| bool is_main_frame = frame_tree_node_->IsMainFrame(); |
| if (base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kSitePerProcess) && |
| !is_main_frame) { |
| // In --site-per-process, subframes delete their RFH rather than storing it |
| // in the proxy. Schedule it for deletion once the SwapOutACK comes in. |
| // TODO(creis): This will be the default when we remove swappedout://. |
| MoveToPendingDeleteHosts(old_render_frame_host.Pass()); |
| } else { |
| // We shouldn't get here for subframes, since we only swap subframes when |
| // --site-per-process is used. |
| DCHECK(is_main_frame); |
| |
| // The old RenderFrameHost will stay alive inside the proxy so that existing |
| // JavaScript window references to it stay valid. |
| proxy->TakeFrameHostOwnership(old_render_frame_host.Pass()); |
| } |
| } |
| |
| void RenderFrameHostManager::DiscardUnusedFrame( |
| scoped_ptr<RenderFrameHostImpl> render_frame_host) { |
| // TODO(carlosk): this code is very similar to what can be found in |
| // SwapOutOldFrame and we should see that these are unified at some point. |
| |
| // If the SiteInstance for the pending RFH is being used by others don't |
| // delete the RFH. Just swap it out and it can be reused at a later point. |
| SiteInstanceImpl* site_instance = render_frame_host->GetSiteInstance(); |
| if (site_instance->HasSite() && site_instance->active_frame_count() > 1) { |
| // Any currently suspended navigations are no longer needed. |
| render_frame_host->CancelSuspendedNavigations(); |
| |
| RenderFrameProxyHost* proxy = |
| new RenderFrameProxyHost(site_instance, frame_tree_node_); |
| proxy_hosts_[site_instance->GetId()] = proxy; |
| |
| // Check if the RenderFrameHost is already swapped out, to avoid swapping it |
| // out again. |
| if (!render_frame_host->is_swapped_out()) |
| render_frame_host->SwapOut(proxy, false); |
| |
| if (frame_tree_node_->IsMainFrame()) |
| proxy->TakeFrameHostOwnership(render_frame_host.Pass()); |
| } else { |
| // We won't be coming back, so delete this one. |
| render_frame_host.reset(); |
| } |
| } |
| |
| void RenderFrameHostManager::MoveToPendingDeleteHosts( |
| scoped_ptr<RenderFrameHostImpl> render_frame_host) { |
| // |render_frame_host| will be deleted when its SwapOut ACK is received, or |
| // when the timer times out, or when the RFHM itself is deleted (whichever |
| // comes first). |
| pending_delete_hosts_.push_back( |
| linked_ptr<RenderFrameHostImpl>(render_frame_host.release())); |
| } |
| |
| bool RenderFrameHostManager::IsPendingDeletion( |
| RenderFrameHostImpl* render_frame_host) { |
| for (const auto& rfh : pending_delete_hosts_) { |
| if (rfh == render_frame_host) |
| return true; |
| } |
| return false; |
| } |
| |
| bool RenderFrameHostManager::DeleteFromPendingList( |
| RenderFrameHostImpl* render_frame_host) { |
| for (RFHPendingDeleteList::iterator iter = pending_delete_hosts_.begin(); |
| iter != pending_delete_hosts_.end(); |
| iter++) { |
| if (*iter == render_frame_host) { |
| pending_delete_hosts_.erase(iter); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void RenderFrameHostManager::ResetProxyHosts() { |
| STLDeleteValues(&proxy_hosts_); |
| } |
| |
| // PlzNavigate |
| void RenderFrameHostManager::BeginNavigation(const NavigationRequest& request) { |
| CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableBrowserSideNavigation)); |
| // Clean up any state in case there's an ongoing navigation. |
| // TODO(carlosk): remove this cleanup here once we properly cancel ongoing |
| // navigations. |
| CleanUpNavigation(); |
| |
| RenderFrameHostImpl* dest_rfh = GetFrameHostForNavigation(request); |
| DCHECK(dest_rfh); |
| } |
| |
| // PlzNavigate |
| RenderFrameHostImpl* RenderFrameHostManager::GetFrameHostForNavigation( |
| const NavigationRequest& request) { |
| CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableBrowserSideNavigation)); |
| |
| SiteInstance* current_site_instance = render_frame_host_->GetSiteInstance(); |
| |
| scoped_refptr<SiteInstance> dest_site_instance = GetSiteInstanceForNavigation( |
| request.common_params().url, request.source_site_instance(), |
| request.dest_site_instance(), request.common_params().transition, |
| request.restore_type() != NavigationEntryImpl::RESTORE_NONE, |
| request.is_view_source()); |
| // The appropriate RenderFrameHost to commit the navigation. |
| RenderFrameHostImpl* navigation_rfh = nullptr; |
| |
| // TODO(carlosk): do not swap processes for renderer initiated navigations |
| // (see crbug.com/440266). |
| if (current_site_instance == dest_site_instance.get() || |
| (!frame_tree_node_->IsMainFrame() && |
| !base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kSitePerProcess))) { |
| // Reuse the current RFH if its SiteInstance matches the the navigation's |
| // or if this is a subframe navigation. We only swap RFHs for subframes when |
| // --site-per-process is enabled. |
| CleanUpNavigation(); |
| navigation_rfh = render_frame_host_.get(); |
| |
| // As SiteInstances are the same, check if the WebUI should be reused. |
| const NavigationEntry* current_navigation_entry = |
| delegate_->GetLastCommittedNavigationEntryForRenderManager(); |
| bool should_reuse_web_ui_ = ShouldReuseWebUI(current_navigation_entry, |
| request.common_params().url); |
| if (!should_reuse_web_ui_) { |
| speculative_web_ui_ = CreateWebUI(request.common_params().url, |
| request.bindings()); |
| // Make sure the current RenderViewHost has the right bindings. |
| if (speculative_web_ui() && |
| !render_frame_host_->GetProcess()->IsIsolatedGuest()) { |
| render_frame_host_->render_view_host()->AllowBindings( |
| speculative_web_ui()->GetBindings()); |
| } |
| } |
| } else { |
| // If the SiteInstance for the final URL doesn't match the one from the |
| // speculatively created RenderFrameHost, create a new RenderFrameHost using |
| // this new SiteInstance. |
| if (!speculative_render_frame_host_ || |
| speculative_render_frame_host_->GetSiteInstance() != |
| dest_site_instance.get()) { |
| CleanUpNavigation(); |
| bool success = CreateSpeculativeRenderFrameHost( |
| request.common_params().url, current_site_instance, |
| dest_site_instance.get(), request.bindings()); |
| DCHECK(success); |
| } |
| DCHECK(speculative_render_frame_host_); |
| navigation_rfh = speculative_render_frame_host_.get(); |
| |
| // Check if our current RFH is live. |
| if (!render_frame_host_->IsRenderFrameLive()) { |
| // 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 navigation to |
| // complete. Just switch to the speculative RFH 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.) |
| CommitPending(); |
| } |
| } |
| DCHECK(navigation_rfh && |
| (navigation_rfh == render_frame_host_.get() || |
| navigation_rfh == speculative_render_frame_host_.get())); |
| |
| // If the RenderFrame that needs to navigate is not live (its process was just |
| // created or has crashed), initialize it. |
| if (!navigation_rfh->IsRenderFrameLive()) { |
| // Recreate the opener chain. |
| int opener_route_id = delegate_->CreateOpenerRenderViewsForRenderManager( |
| navigation_rfh->GetSiteInstance()); |
| if (!InitRenderView(navigation_rfh->render_view_host(), opener_route_id, |
| MSG_ROUTING_NONE, frame_tree_node_->IsMainFrame())) { |
| return nullptr; |
| } |
| } |
| |
| cross_navigation_pending_ = navigation_rfh != render_frame_host_.get(); |
| return navigation_rfh; |
| } |
| |
| // PlzNavigate |
| void RenderFrameHostManager::CleanUpNavigation() { |
| CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableBrowserSideNavigation)); |
| speculative_web_ui_.reset(); |
| should_reuse_web_ui_ = false; |
| if (speculative_render_frame_host_) |
| DiscardUnusedFrame(UnsetSpeculativeRenderFrameHost()); |
| } |
| |
| // PlzNavigate |
| scoped_ptr<RenderFrameHostImpl> |
| RenderFrameHostManager::UnsetSpeculativeRenderFrameHost() { |
| CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableBrowserSideNavigation)); |
| speculative_render_frame_host_->GetProcess()->RemovePendingView(); |
| return speculative_render_frame_host_.Pass(); |
| } |
| |
| void RenderFrameHostManager::OnDidStartLoading() { |
| for (const auto& pair : proxy_hosts_) { |
| pair.second->Send( |
| new FrameMsg_DidStartLoading(pair.second->GetRoutingID())); |
| } |
| } |
| |
| void RenderFrameHostManager::OnDidStopLoading() { |
| for (const auto& pair : proxy_hosts_) { |
| pair.second->Send(new FrameMsg_DidStopLoading(pair.second->GetRoutingID())); |
| } |
| } |
| |
| void RenderFrameHostManager::Observe( |
| int type, |
| const NotificationSource& source, |
| const NotificationDetails& details) { |
| switch (type) { |
| case NOTIFICATION_RENDERER_PROCESS_CLOSED: |
| case NOTIFICATION_RENDERER_PROCESS_CLOSING: |
| RendererProcessClosing( |
| Source<RenderProcessHost>(source).ptr()); |
| break; |
| |
| default: |
| NOTREACHED(); |
| } |
| } |
| |
| // static |
| bool RenderFrameHostManager::ClearProxiesInSiteInstance( |
| int32 site_instance_id, |
| FrameTreeNode* node) { |
| RenderFrameProxyHostMap::iterator iter = |
| node->render_manager()->proxy_hosts_.find(site_instance_id); |
| if (iter != node->render_manager()->proxy_hosts_.end()) { |
| RenderFrameProxyHost* proxy = iter->second; |
| // Delete the proxy. If it is for a main frame (and thus the RFH is stored |
| // in the proxy) and it was still pending swap out, move the RFH to the |
| // pending deletion list first. |
| if (node->IsMainFrame() && |
| proxy->render_frame_host()->rfh_state() == |
| RenderFrameHostImpl::STATE_PENDING_SWAP_OUT) { |
| scoped_ptr<RenderFrameHostImpl> swapped_out_rfh = |
| proxy->PassFrameHostOwnership(); |
| node->render_manager()->MoveToPendingDeleteHosts(swapped_out_rfh.Pass()); |
| } |
| delete proxy; |
| node->render_manager()->proxy_hosts_.erase(site_instance_id); |
| } |
| |
| return true; |
| } |
| |
| // static. |
| bool RenderFrameHostManager::ResetProxiesInSiteInstance(int32 site_instance_id, |
| FrameTreeNode* node) { |
| RenderFrameProxyHostMap::iterator iter = |
| node->render_manager()->proxy_hosts_.find(site_instance_id); |
| if (iter != node->render_manager()->proxy_hosts_.end()) |
| iter->second->set_render_frame_proxy_created(false); |
| |
| return true; |
| } |
| |
| bool RenderFrameHostManager::ShouldTransitionCrossSite() { |
| // True for --site-per-process, which overrides both kSingleProcess and |
| // kProcessPerTab. |
| if (base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kSitePerProcess)) |
| return true; |
| |
| // False in the single-process mode, as it makes RVHs to accumulate |
| // in swapped_out_hosts_. |
| // True if we are using process-per-site-instance (default) or |
| // process-per-site (kProcessPerSite). |
| return !base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kSingleProcess) && |
| !base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kProcessPerTab); |
| } |
| |
| bool RenderFrameHostManager::ShouldSwapBrowsingInstancesForNavigation( |
| const GURL& current_effective_url, |
| bool current_is_view_source_mode, |
| SiteInstance* new_site_instance, |
| const GURL& new_effective_url, |
| bool new_is_view_source_mode) const { |
| // If new_entry already has a SiteInstance, assume it is correct. We only |
| // need to force a swap if it is in a different BrowsingInstance. |
| if (new_site_instance) { |
| return !new_site_instance->IsRelatedSiteInstance( |
| render_frame_host_->GetSiteInstance()); |
| } |
| |
| // Check for reasons to swap processes even if we are in a process model that |
| // doesn't usually swap (e.g., process-per-tab). Any time we return true, |
| // the new_entry will be rendered in a new SiteInstance AND BrowsingInstance. |
| BrowserContext* browser_context = |
| delegate_->GetControllerForRenderManager().GetBrowserContext(); |
| |
| // Don't force a new BrowsingInstance for debug URLs that are handled in the |
| // renderer process, like javascript: or chrome://crash. |
| if (IsRendererDebugURL(new_effective_url)) |
| return false; |
| |
| // For security, we should transition between processes when one is a Web UI |
| // page and one isn't. |
| if (ChildProcessSecurityPolicyImpl::GetInstance()->HasWebUIBindings( |
| render_frame_host_->GetProcess()->GetID()) || |
| WebUIControllerFactoryRegistry::GetInstance()->UseWebUIForURL( |
| browser_context, current_effective_url)) { |
| // If so, force a swap if destination is not an acceptable URL for Web UI. |
| // Here, data URLs are never allowed. |
| if (!WebUIControllerFactoryRegistry::GetInstance()->IsURLAcceptableForWebUI( |
| browser_context, new_effective_url)) { |
| return true; |
| } |
| } else { |
| // Force a swap if it's a Web UI URL. |
| if (WebUIControllerFactoryRegistry::GetInstance()->UseWebUIForURL( |
| browser_context, new_effective_url)) { |
| return true; |
| } |
| } |
| |
| // Check with the content client as well. Important to pass |
| // current_effective_url here, which uses the SiteInstance's site if there is |
| // no current_entry. |
| if (GetContentClient()->browser()->ShouldSwapBrowsingInstancesForNavigation( |
| render_frame_host_->GetSiteInstance(), |
| current_effective_url, new_effective_url)) { |
| return true; |
| } |
| |
| // We can't switch a RenderView between view source and non-view source mode |
| // without screwing up the session history sometimes (when navigating between |
| // "view-source:http://foo.com/" and "http://foo.com/", Blink doesn't treat |
| // it as a new navigation). So require a BrowsingInstance switch. |
| if (current_is_view_source_mode != new_is_view_source_mode) |
| return true; |
| |
| return false; |
| } |
| |
| bool RenderFrameHostManager::ShouldReuseWebUI( |
| const NavigationEntry* current_entry, |
| const GURL& new_url) const { |
| NavigationControllerImpl& controller = |
| delegate_->GetControllerForRenderManager(); |
| return current_entry && web_ui_.get() && |
| (WebUIControllerFactoryRegistry::GetInstance()->GetWebUIType( |
| controller.GetBrowserContext(), current_entry->GetURL()) == |
| WebUIControllerFactoryRegistry::GetInstance()->GetWebUIType( |
| controller.GetBrowserContext(), new_url)); |
| } |
| |
| SiteInstance* RenderFrameHostManager::GetSiteInstanceForNavigation( |
| const GURL& dest_url, |
| SiteInstance* source_instance, |
| SiteInstance* dest_instance, |
| ui::PageTransition transition, |
| bool dest_is_restore, |
| bool dest_is_view_source_mode) { |
| SiteInstance* current_instance = render_frame_host_->GetSiteInstance(); |
| SiteInstance* new_instance = current_instance; |
| |
| // We do not currently swap processes for navigations in webview tag guests. |
| if (current_instance->GetSiteURL().SchemeIs(kGuestScheme)) |
| return current_instance; |
| |
| // 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. |
| // This is used for cases that require a process swap even in the |
| // process-per-tab model, such as WebUI pages. |
| // TODO(clamy): Remove the dependency on the current entry. |
| const NavigationEntry* current_entry = |
| delegate_->GetLastCommittedNavigationEntryForRenderManager(); |
| BrowserContext* browser_context = |
| delegate_->GetControllerForRenderManager().GetBrowserContext(); |
| const GURL& current_effective_url = current_entry ? |
| SiteInstanceImpl::GetEffectiveURL(browser_context, |
| current_entry->GetURL()) : |
| render_frame_host_->GetSiteInstance()->GetSiteURL(); |
| bool current_is_view_source_mode = current_entry ? |
| current_entry->IsViewSourceMode() : dest_is_view_source_mode; |
| bool force_swap = ShouldSwapBrowsingInstancesForNavigation( |
| current_effective_url, |
| current_is_view_source_mode, |
| dest_instance, |
| SiteInstanceImpl::GetEffectiveURL(browser_context, dest_url), |
| dest_is_view_source_mode); |
| if (ShouldTransitionCrossSite() || force_swap) { |
| new_instance = GetSiteInstanceForURL( |
| dest_url, source_instance, current_instance, dest_instance, |
| transition, dest_is_restore, dest_is_view_source_mode, 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. |
| if (force_swap) |
| CHECK_NE(new_instance, current_instance); |
| return new_instance; |
| } |
| |
| SiteInstance* RenderFrameHostManager::GetSiteInstanceForURL( |
| const GURL& dest_url, |
| SiteInstance* source_instance, |
| SiteInstance* current_instance, |
| SiteInstance* dest_instance, |
| ui::PageTransition transition, |
| bool dest_is_restore, |
| bool dest_is_view_source_mode, |
| bool force_browsing_instance_swap) { |
| NavigationControllerImpl& controller = |
| delegate_->GetControllerForRenderManager(); |
| BrowserContext* browser_context = controller.GetBrowserContext(); |
| |
| // If the entry has an instance already we should use it. |
| if (dest_instance) { |
| // If we are forcing a swap, this should be in a different BrowsingInstance. |
| if (force_browsing_instance_swap) { |
| CHECK(!dest_instance->IsRelatedSiteInstance( |
| render_frame_host_->GetSiteInstance())); |
| } |
| return dest_instance; |
| } |
| |
| // If a swap is required, we need to force the SiteInstance AND |
| // BrowsingInstance to be different ones, using CreateForURL. |
| if (force_browsing_instance_swap) |
| return SiteInstance::CreateForURL(browser_context, dest_url); |
| |
| // (UGLY) HEURISTIC, process-per-site only: |
| // |
| // If this navigation is generated, then it probably corresponds to a search |
| // query. Given that search results typically lead to users navigating to |
| // other sites, we don't really want to use the search engine hostname to |
| // determine the site instance for this navigation. |
| // |
| // NOTE: This can be removed once we have a way to transition between |
| // RenderViews in response to a link click. |
| // |
| if (base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kProcessPerSite) && |
| ui::PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_GENERATED)) { |
| return current_instance; |
| } |
| |
| SiteInstanceImpl* current_site_instance = |
| static_cast<SiteInstanceImpl*>(current_instance); |
| |
| // If we haven't used our SiteInstance (and thus RVH) yet, then we can use it |
| // for this entry. We won't commit the SiteInstance to this site until the |
| // navigation commits (in DidNavigate), unless the navigation entry was |
| // restored or it's a Web UI as described below. |
| if (!current_site_instance->HasSite()) { |
| // If we've already created a SiteInstance for our destination, we don't |
| // want to use this unused SiteInstance; use the existing one. (We don't |
| // do this check if the current_instance has a site, because for now, we |
| // want to compare against the current URL and not the SiteInstance's site. |
| // In this case, there is no current URL, so comparing against the site is |
| // ok. See additional comments below.) |
| // |
| // Also, if the URL should use process-per-site mode and there is an |
| // existing process for the site, we should use it. We can call |
| // GetRelatedSiteInstance() for this, which will eagerly set the site and |
| // thus use the correct process. |
| bool use_process_per_site = |
| RenderProcessHost::ShouldUseProcessPerSite(browser_context, dest_url) && |
| RenderProcessHostImpl::GetProcessHostForSite(browser_context, dest_url); |
| if (current_site_instance->HasRelatedSiteInstance(dest_url) || |
| use_process_per_site) { |
| return current_site_instance->GetRelatedSiteInstance(dest_url); |
| } |
| |
| // For extensions, Web UI URLs (such as the new tab page), and apps we do |
| // not want to use the current_instance if it has no site, since it will |
| // have a RenderProcessHost of PRIV_NORMAL. Create a new SiteInstance for |
| // this URL instead (with the correct process type). |
| if (current_site_instance->HasWrongProcessForURL(dest_url)) |
| return current_site_instance->GetRelatedSiteInstance(dest_url); |
| |
| // View-source URLs must use a new SiteInstance and BrowsingInstance. |
| // TODO(nasko): This is the same condition as later in the function. This |
| // should be taken into account when refactoring this method as part of |
| // http://crbug.com/123007. |
| if (dest_is_view_source_mode) |
| return SiteInstance::CreateForURL(browser_context, dest_url); |
| |
| // If we are navigating from a blank SiteInstance to a WebUI, make sure we |
| // create a new SiteInstance. |
| if (WebUIControllerFactoryRegistry::GetInstance()->UseWebUIForURL( |
| browser_context, dest_url)) { |
| return SiteInstance::CreateForURL(browser_context, dest_url); |
| } |
| |
| // Normally the "site" on the SiteInstance is set lazily when the load |
| // actually commits. This is to support better process sharing in case |
| // the site redirects to some other site: we want to use the destination |
| // site in the site instance. |
| // |
| // In the case of session restore, as it loads all the pages immediately |
| // we need to set the site first, otherwise after a restore none of the |
| // pages would share renderers in process-per-site. |
| // |
| // The embedder can request some urls never to be assigned to SiteInstance |
| // through the ShouldAssignSiteForURL() content client method, so that |
| // renderers created for particular chrome urls (e.g. the chrome-native:// |
| // scheme) can be reused for subsequent navigations in the same WebContents. |
| // See http://crbug.com/386542. |
| if (dest_is_restore && |
| GetContentClient()->browser()->ShouldAssignSiteForURL(dest_url)) { |
| current_site_instance->SetSite(dest_url); |
| } |
| |
| return current_site_instance; |
| } |
| |
| // Otherwise, only create a new SiteInstance for a cross-site navigation. |
| |
| // TODO(creis): Once we intercept links and script-based navigations, we |
| // will be able to enforce that all entries in a SiteInstance actually have |
| // the same site, and it will be safe to compare the URL against the |
| // SiteInstance's site, as follows: |
| // const GURL& current_url = current_instance->site(); |
| // For now, though, we're in a hybrid model where you only switch |
| // SiteInstances if you type in a cross-site URL. This means we have to |
| // compare the entry's URL to the last committed entry's URL. |
| NavigationEntry* current_entry = controller.GetLastCommittedEntry(); |
| if (interstitial_page_) { |
| // The interstitial is currently the last committed entry, but we want to |
| // compare against the last non-interstitial entry. |
| current_entry = controller.GetEntryAtOffset(-1); |
| } |
| |
| // View-source URLs must use a new SiteInstance and BrowsingInstance. |
| // We don't need a swap when going from view-source to a debug URL like |
| // chrome://crash, however. |
| // TODO(creis): Refactor this method so this duplicated code isn't needed. |
| // See http://crbug.com/123007. |
| if (current_entry && |
| current_entry->IsViewSourceMode() != dest_is_view_source_mode && |
| !IsRendererDebugURL(dest_url)) { |
| return SiteInstance::CreateForURL(browser_context, dest_url); |
| } |
| |
| // Use the source SiteInstance in case of data URLs or about:blank pages, |
| // because the content is then controlled and/or scriptable by the source |
| // SiteInstance. |
| GURL about_blank(url::kAboutBlankURL); |
| if (source_instance && |
| (dest_url == about_blank || dest_url.scheme() == url::kDataScheme)) |
| return source_instance; |
| |
| // Use the current SiteInstance for same site navigations, as long as the |
| // process type is correct. (The URL may have been installed as an app since |
| // the last time we visited it.) |
| const GURL& current_url = |
| GetCurrentURLForSiteInstance(current_instance, current_entry); |
| if (SiteInstance::IsSameWebSite(browser_context, current_url, dest_url) && |
| !current_site_instance->HasWrongProcessForURL(dest_url)) { |
| return current_instance; |
| } |
| |
| // Start the new renderer in a new SiteInstance, but in the current |
| // BrowsingInstance. It is important to immediately give this new |
| // SiteInstance to a RenderViewHost (if it is different than our current |
| // SiteInstance), so that it is ref counted. This will happen in |
| // CreateRenderView. |
| return current_instance->GetRelatedSiteInstance(dest_url); |
| } |
| |
| const GURL& RenderFrameHostManager::GetCurrentURLForSiteInstance( |
| SiteInstance* current_instance, NavigationEntry* current_entry) { |
| // If this is a subframe that is potentially out of process from its parent, |
| // don't consider using current_entry's url for SiteInstance selection, since |
| // current_entry's url is for the main frame and may be in a different site |
| // than this frame. |
| // TODO(creis): Remove this when we can check the FrameNavigationEntry's url. |
| // See http://crbug.com/369654 |
| if (!frame_tree_node_->IsMainFrame() && |
| base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kSitePerProcess)) |
| return frame_tree_node_->current_url(); |
| |
| // If there is no last non-interstitial entry (and current_instance already |
| // has a site), then we must have been opened from another tab. We want |
| // to compare against the URL of the page that opened us, but we can't |
| // get to it directly. The best we can do is check against the site of |
| // the SiteInstance. This will be correct when we intercept links and |
| // script-based navigations, but for now, it could place some pages in a |
| // new process unnecessarily. We should only hit this case if a page tries |
| // to open a new tab to an interstitial-inducing URL, and then navigates |
| // the page to a different same-site URL. (This seems very unlikely in |
| // practice.) |
| if (current_entry) |
| return current_entry->GetURL(); |
| return current_instance->GetSiteURL(); |
| } |
| |
| void RenderFrameHostManager::CreatePendingRenderFrameHost( |
| SiteInstance* old_instance, |
| SiteInstance* new_instance, |
| bool is_main_frame) { |
| int create_render_frame_flags = 0; |
| if (is_main_frame) |
| create_render_frame_flags |= CREATE_RF_FOR_MAIN_FRAME_NAVIGATION; |
| |
| if (delegate_->IsHidden()) |
| create_render_frame_flags |= CREATE_RF_HIDDEN; |
| |
| int opener_route_id = CreateOpenerRenderViewsIfNeeded( |
| old_instance, new_instance, &create_render_frame_flags); |
| |
| if (pending_render_frame_host_) |
| CancelPending(); |
| |
| // Create a non-swapped-out RFH with the given opener. |
| pending_render_frame_host_ = |
| CreateRenderFrame(new_instance, pending_web_ui(), opener_route_id, |
| create_render_frame_flags, nullptr); |
| } |
| |
| int RenderFrameHostManager::CreateOpenerRenderViewsIfNeeded( |
| SiteInstance* old_instance, |
| SiteInstance* new_instance, |
| int* create_render_frame_flags) { |
| int opener_route_id = MSG_ROUTING_NONE; |
| if (new_instance->IsRelatedSiteInstance(old_instance)) { |
| opener_route_id = |
| delegate_->CreateOpenerRenderViewsForRenderManager(new_instance); |
| if (base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kSitePerProcess)) { |
| // Ensure that the frame tree has RenderFrameProxyHosts for the new |
| // SiteInstance in all nodes except the current one. |
| frame_tree_node_->frame_tree()->CreateProxiesForSiteInstance( |
| frame_tree_node_, new_instance); |
| // RenderFrames in different processes from their parent RenderFrames |
| // in the frame tree require RenderWidgets for rendering and processing |
| // input events. |
| if (frame_tree_node_->parent() && |
| frame_tree_node_->parent()->current_frame_host()->GetSiteInstance() != |
| new_instance) |
| *create_render_frame_flags |= CREATE_RF_NEEDS_RENDER_WIDGET_HOST; |
| } |
| } |
| return opener_route_id; |
| } |
| |
| scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrameHost( |
| SiteInstance* site_instance, |
| int view_routing_id, |
| int frame_routing_id, |
| int flags) { |
| if (frame_routing_id == MSG_ROUTING_NONE) |
| frame_routing_id = site_instance->GetProcess()->GetNextRoutingID(); |
| |
| bool swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT); |
| bool hidden = !!(flags & CREATE_RF_HIDDEN); |
| |
| // 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 = nullptr; |
| if (frame_tree_node_->IsMainFrame()) { |
| render_view_host = frame_tree->CreateRenderViewHost( |
| site_instance, view_routing_id, frame_routing_id, swapped_out, hidden); |
| } else { |
| render_view_host = frame_tree->GetRenderViewHost(site_instance); |
| |
| CHECK(render_view_host); |
| } |
| |
| // TODO(creis): Pass hidden to RFH. |
| scoped_ptr<RenderFrameHostImpl> render_frame_host = make_scoped_ptr( |
| RenderFrameHostFactory::Create( |
| site_instance, render_view_host, render_frame_delegate_, |
| render_widget_delegate_, frame_tree, frame_tree_node_, |
| frame_routing_id, flags).release()); |
| return render_frame_host.Pass(); |
| } |
| |
| // PlzNavigate |
| bool RenderFrameHostManager::CreateSpeculativeRenderFrameHost( |
| const GURL& url, |
| SiteInstance* old_instance, |
| SiteInstance* new_instance, |
| int bindings) { |
| CHECK(new_instance); |
| CHECK_NE(old_instance, new_instance); |
| CHECK(!should_reuse_web_ui_); |
| |
| // Note: |speculative_web_ui_| must be initialized before starting the |
| // |speculative_render_frame_host_| creation steps otherwise the WebUI |
| // won't be properly initialized. |
| speculative_web_ui_ = CreateWebUI(url, bindings); |
| |
| int create_render_frame_flags = 0; |
| int opener_route_id = |
| CreateOpenerRenderViewsIfNeeded(old_instance, new_instance, |
| &create_render_frame_flags); |
| |
| if (frame_tree_node_->IsMainFrame()) |
| create_render_frame_flags |= CREATE_RF_FOR_MAIN_FRAME_NAVIGATION; |
| if (delegate_->IsHidden()) |
| create_render_frame_flags |= CREATE_RF_HIDDEN; |
| speculative_render_frame_host_ = |
| CreateRenderFrame(new_instance, speculative_web_ui_.get(), |
| opener_route_id, create_render_frame_flags, nullptr); |
| |
| if (!speculative_render_frame_host_) { |
| speculative_web_ui_.reset(); |
| return false; |
| } |
| return true; |
| } |
| |
| scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrame( |
| SiteInstance* instance, |
| WebUIImpl* web_ui, |
| int opener_route_id, |
| int flags, |
| int* view_routing_id_ptr) { |
| bool swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT); |
| CHECK(instance); |
| // Swapped out views should always be hidden. |
| DCHECK(!swapped_out || (flags & CREATE_RF_HIDDEN)); |
| |
| // TODO(nasko): Remove the following CHECK once cross-site navigation no |
| // longer relies on swapped out RFH for the top-level frame. |
| if (!frame_tree_node_->IsMainFrame()) |
| CHECK(!swapped_out); |
| |
| scoped_ptr<RenderFrameHostImpl> new_render_frame_host; |
| bool success = true; |
| if (view_routing_id_ptr) |
| *view_routing_id_ptr = MSG_ROUTING_NONE; |
| |
| // We are creating a pending, speculative or swapped out RFH here. We should |
| // never create it in the same SiteInstance as our current RFH. |
| CHECK_NE(render_frame_host_->GetSiteInstance(), instance); |
| |
| // Check if we've already created an RFH 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 proxy hosts below if it will be active. |
| RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance); |
| if (proxy && proxy->render_frame_host()) { |
| if (view_routing_id_ptr) |
| *view_routing_id_ptr = proxy->GetRenderViewHost()->GetRoutingID(); |
| // Delete the existing RenderFrameProxyHost, but reuse the RenderFrameHost. |
| // Prevent the process from exiting while we're trying to use it. |
| if (!swapped_out) { |
| new_render_frame_host = proxy->PassFrameHostOwnership(); |
| new_render_frame_host->GetProcess()->AddPendingView(); |
| |
| proxy_hosts_.erase(instance->GetId()); |
| delete proxy; |
| |
| // When a new render view is created by the renderer, the new WebContents |
| // gets a RenderViewHost in the SiteInstance of its opener WebContents. |
| // If not used in the first navigation, this RVH is swapped out and is not |
| // granted bindings, so we may need to grant them when swapping it in. |
| if (web_ui && !new_render_frame_host->GetProcess()->IsIsolatedGuest()) { |
| int required_bindings = web_ui->GetBindings(); |
| RenderViewHost* render_view_host = |
| new_render_frame_host->render_view_host(); |
| if ((render_view_host->GetEnabledBindings() & required_bindings) != |
| required_bindings) { |
| render_view_host->AllowBindings(required_bindings); |
| } |
| } |
| } |
| } else { |
| // Create a new RenderFrameHost if we don't find an existing one. |
| new_render_frame_host = CreateRenderFrameHost(instance, MSG_ROUTING_NONE, |
| MSG_ROUTING_NONE, flags); |
| RenderViewHostImpl* render_view_host = |
| new_render_frame_host->render_view_host(); |
| int proxy_routing_id = MSG_ROUTING_NONE; |
| |
| // Prevent the process from exiting while we're trying to navigate in it. |
| // Otherwise, if the new RFH is swapped out already, store it. |
| if (!swapped_out) { |
| new_render_frame_host->GetProcess()->AddPendingView(); |
| } else { |
| proxy = new RenderFrameProxyHost( |
| new_render_frame_host->GetSiteInstance(), frame_tree_node_); |
| proxy_hosts_[instance->GetId()] = proxy; |
| proxy_routing_id = proxy->GetRoutingID(); |
| proxy->TakeFrameHostOwnership(new_render_frame_host.Pass()); |
| } |
| |
| success = |
| InitRenderView(render_view_host, opener_route_id, proxy_routing_id, |
| !!(flags & CREATE_RF_FOR_MAIN_FRAME_NAVIGATION)); |
| if (success) { |
| if (frame_tree_node_->IsMainFrame()) { |
| // Don't show the main frame's view until we get a DidNavigate from it. |
| // Only the RenderViewHost for the top-level RenderFrameHost has a |
| // RenderWidgetHostView; RenderWidgetHosts for out-of-process iframes |
| // will be created later and hidden. |
| if (render_view_host->GetView()) |
| render_view_host->GetView()->Hide(); |
| } else if (!swapped_out) { |
| // Init the RFH, so a RenderFrame is created in the renderer. |
| DCHECK(new_render_frame_host.get()); |
| success = InitRenderFrame(new_render_frame_host.get()); |
| } |
| } |
| |
| if (success) { |
| if (view_routing_id_ptr) |
| *view_routing_id_ptr = render_view_host->GetRoutingID(); |
| |
| // A brand new RenderFrame was created by one of the Init calls above. |
| // Announce it to observers. |
| if (swapped_out) |
| render_frame_delegate_->RenderFrameCreated(proxy->render_frame_host()); |
| else |
| render_frame_delegate_->RenderFrameCreated(new_render_frame_host.get()); |
| } |
| } |
| |
| // Returns the new RFH if it isn't swapped out. |
| if (success && !swapped_out) { |
| DCHECK(new_render_frame_host->GetSiteInstance() == instance); |
| return new_render_frame_host.Pass(); |
| } |
| return nullptr; |
| } |
| |
| int RenderFrameHostManager::CreateRenderFrameProxy(SiteInstance* instance) { |
| // A RenderFrameProxyHost should never be created in the same SiteInstance as |
| // the current RFH. |
| CHECK(instance); |
| CHECK_NE(instance, render_frame_host_->GetSiteInstance()); |
| |
| RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance); |
| if (proxy) |
| return proxy->GetRoutingID(); |
| |
| proxy = new RenderFrameProxyHost(instance, frame_tree_node_); |
| proxy_hosts_[instance->GetId()] = proxy; |
| proxy->InitRenderFrameProxy(); |
| return proxy->GetRoutingID(); |
| } |
| |
| void RenderFrameHostManager::EnsureRenderViewInitialized( |
| FrameTreeNode* source, |
| RenderViewHostImpl* render_view_host, |
| SiteInstance* instance) { |
| DCHECK(frame_tree_node_->IsMainFrame()); |
| |
| if (render_view_host->IsRenderViewLive()) |
| return; |
| |
| // Recreate the opener chain. |
| int opener_route_id = |
| delegate_->CreateOpenerRenderViewsForRenderManager(instance); |
| RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance); |
| InitRenderView(render_view_host, opener_route_id, proxy->GetRoutingID(), |
| source->IsMainFrame()); |
| } |
| |
| bool RenderFrameHostManager::InitRenderView( |
| RenderViewHostImpl* render_view_host, |
| int opener_route_id, |
| int proxy_routing_id, |
| bool for_main_frame_navigation) { |
| // We may have initialized this RenderViewHost for another RenderFrameHost. |
| if (render_view_host->IsRenderViewLive()) |
| return true; |
| |
| // If the ongoing navigation is to a WebUI and the RenderView is not in a |
| // guest process, tell the RenderViewHost about any bindings it will need |
| // enabled. |
| WebUIImpl* dest_web_ui = nullptr; |
| if (base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableBrowserSideNavigation)) { |
| dest_web_ui = |
| should_reuse_web_ui_ ? web_ui_.get() : speculative_web_ui_.get(); |
| } else { |
| dest_web_ui = pending_web_ui(); |
| } |
| if (dest_web_ui && !render_view_host->GetProcess()->IsIsolatedGuest()) { |
| render_view_host->AllowBindings(dest_web_ui->GetBindings()); |
| } else { |
| // Ensure that we don't create an unprivileged RenderView in a WebUI-enabled |
| // process unless it's swapped out. |
| if (render_view_host->is_active()) { |
| CHECK(!ChildProcessSecurityPolicyImpl::GetInstance()->HasWebUIBindings( |
| render_view_host->GetProcess()->GetID())); |
| } |
| } |
| |
| return delegate_->CreateRenderViewForRenderManager(render_view_host, |
| opener_route_id, |
| proxy_routing_id, |
| for_main_frame_navigation); |
| } |
| |
| bool RenderFrameHostManager::InitRenderFrame( |
| RenderFrameHostImpl* render_frame_host) { |
| if (render_frame_host->IsRenderFrameLive()) |
| return true; |
| |
| int parent_routing_id = MSG_ROUTING_NONE; |
| int proxy_routing_id = MSG_ROUTING_NONE; |
| if (frame_tree_node_->parent()) { |
| parent_routing_id = frame_tree_node_->parent()->render_manager()-> |
| GetRoutingIdForSiteInstance(render_frame_host->GetSiteInstance()); |
| CHECK_NE(parent_routing_id, MSG_ROUTING_NONE); |
| } |
| // Check whether there is an existing proxy for this frame in this |
| // SiteInstance. If there is, the new RenderFrame needs to be able to find |
| // the proxy it is replacing, so that it can fully initialize itself. |
| // NOTE: This is the only time that a RenderFrameProxyHost can be in the same |
| // SiteInstance as its RenderFrameHost. This is only the case until the |
| // RenderFrameHost commits, at which point it will replace and delete the |
| // RenderFrameProxyHost. |
| RenderFrameProxyHost* existing_proxy = |
| GetRenderFrameProxyHost(render_frame_host->GetSiteInstance()); |
| if (existing_proxy) { |
| proxy_routing_id = existing_proxy->GetRoutingID(); |
| CHECK_NE(proxy_routing_id, MSG_ROUTING_NONE); |
| if (!existing_proxy->is_render_frame_proxy_live()) |
| existing_proxy->InitRenderFrameProxy(); |
| } |
| return delegate_->CreateRenderFrameForRenderManager(render_frame_host, |
| parent_routing_id, |
| proxy_routing_id); |
| } |
| |
| int RenderFrameHostManager::GetRoutingIdForSiteInstance( |
| SiteInstance* site_instance) { |
| if (render_frame_host_->GetSiteInstance() == site_instance) |
| return render_frame_host_->GetRoutingID(); |
| |
| RenderFrameProxyHostMap::iterator iter = |
| proxy_hosts_.find(site_instance->GetId()); |
| if (iter != proxy_hosts_.end()) |
| return iter->second->GetRoutingID(); |
| |
| return MSG_ROUTING_NONE; |
| } |
| |
| void RenderFrameHostManager::CommitPending() { |
| TRACE_EVENT1("navigation", "RenderFrameHostManager::CommitPending", |
| "FrameTreeNode id", frame_tree_node_->frame_tree_node_id()); |
| bool browser_side_navigation = |
| base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableBrowserSideNavigation); |
| // First check whether we're going to want to focus the location bar after |
| // this commit. We do this now because the navigation hasn't formally |
| // committed yet, so if we've already cleared |pending_web_ui_| the call chain |
| // this triggers won't be able to figure out what's going on. |
| bool will_focus_location_bar = delegate_->FocusLocationBarByDefault(); |
| |
| if (!browser_side_navigation) { |
| DCHECK(!speculative_web_ui_); |
| // Next commit the Web UI, if any. Either replace |web_ui_| with |
| // |pending_web_ui_|, or clear |web_ui_| if there is no pending WebUI, or |
| // leave |web_ui_| as is if reusing it. |
| DCHECK(!(pending_web_ui_.get() && pending_and_current_web_ui_.get())); |
| if (pending_web_ui_) { |
| web_ui_.reset(pending_web_ui_.release()); |
| } else if (!pending_and_current_web_ui_.get()) { |
| web_ui_.reset(); |
| } else { |
| DCHECK_EQ(pending_and_current_web_ui_.get(), web_ui_.get()); |
| pending_and_current_web_ui_.reset(); |
| } |
| } else { |
| // PlzNavigate |
| if (!should_reuse_web_ui_) |
| web_ui_.reset(speculative_web_ui_.release()); |
| DCHECK(!speculative_web_ui_); |
| } |
| |
| // It's possible for the pending_render_frame_host_ to be nullptr 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_ && !speculative_render_frame_host_) { |
| if (will_focus_location_bar) |
| delegate_->SetFocusToLocationBar(false); |
| return; |
| } |
| |
| // 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_->GetView() && |
| render_frame_host_->GetView()->HasFocus(); |
| |
| bool is_main_frame = frame_tree_node_->IsMainFrame(); |
| |
| // Swap in the pending or speculative frame and make it active. Also ensure |
| // the FrameTree stays in sync. |
| scoped_ptr<RenderFrameHostImpl> old_render_frame_host; |
| if (!browser_side_navigation) { |
| DCHECK(!speculative_render_frame_host_); |
| old_render_frame_host = |
| SetRenderFrameHost(pending_render_frame_host_.Pass()); |
| } else { |
| // PlzNavigate |
| DCHECK(speculative_render_frame_host_); |
| old_render_frame_host = |
| SetRenderFrameHost(speculative_render_frame_host_.Pass()); |
| } |
| cross_navigation_pending_ = false; |
| |
| if (is_main_frame) |
| render_frame_host_->render_view_host()->AttachToFrameTree(); |
| |
| // The process will no longer try to exit, so we can decrement the count. |
| render_frame_host_->GetProcess()->RemovePendingView(); |
| |
| // Show the new view (or a sad tab) if necessary. |
| bool new_rfh_has_view = !!render_frame_host_->GetView(); |
| if (!delegate_->IsHidden() && new_rfh_has_view) { |
| // In most cases, we need to show the new view. |
| render_frame_host_->GetView()->Show(); |
| } |
| if (!new_rfh_has_view) { |
| // 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. |
| DCHECK(!render_frame_host_->IsRenderFrameLive()); |
| DCHECK(!render_frame_host_->render_view_host()->IsRenderViewLive()); |
| delegate_->RenderProcessGoneFromRenderManager( |
| render_frame_host_->render_view_host()); |
| } |
| |
| // For top-level frames, also hide the old RenderViewHost's view. |
| // TODO(creis): As long as show/hide are on RVH, we don't want to hide on |
| // subframe navigations or we will interfere with the top-level frame. |
| if (is_main_frame && old_render_frame_host->render_view_host()->GetView()) |
| old_render_frame_host->render_view_host()->GetView()->Hide(); |
| |
| // Make sure the size is up to date. (Fix for bug 1079768.) |
| delegate_->UpdateRenderViewSizeForRenderManager(); |
| |
| if (will_focus_location_bar) { |
| delegate_->SetFocusToLocationBar(false); |
| } else if (focus_render_view && render_frame_host_->GetView()) { |
| render_frame_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. |
| delegate_->NotifySwappedFromRenderManager( |
| old_render_frame_host.get(), render_frame_host_.get(), is_main_frame); |
| |
| // Swap out the old frame now that the new one is visible. |
| // This will swap it out and then put it on the proxy list (if there are other |
| // active views in its SiteInstance) or schedule it for deletion when the swap |
| // out ack arrives (or immediately if the process isn't live). |
| // In the --site-per-process case, old subframe RHFs are not kept alive inside |
| // the proxy. |
| SwapOutOldFrame(old_render_frame_host.Pass()); |
| |
| if (base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kSitePerProcess) && |
| !is_main_frame) { |
| // If this is a subframe, it should have a CrossProcessFrameConnector |
| // created already. Use it to link the new RFH's view to the proxy that |
| // belongs to the parent frame's SiteInstance. |
| // Note: We do this after swapping out the old RFH because that may create |
| // the proxy we're looking for. |
| RenderFrameProxyHost* proxy_to_parent = GetProxyToParent(); |
| if (proxy_to_parent) { |
| proxy_to_parent->SetChildRWHView(render_frame_host_->GetView()); |
| } |
| |
| // Since the new RenderFrameHost is now committed, there must be no proxies |
| // for its SiteInstance. Delete any existing ones. |
| RenderFrameProxyHostMap::iterator iter = |
| proxy_hosts_.find(render_frame_host_->GetSiteInstance()->GetId()); |
| if (iter != proxy_hosts_.end()) { |
| delete iter->second; |
| proxy_hosts_.erase(iter); |
| } |
| } |
| |
| // After all is done, there must never be a proxy in the list which has the |
| // same SiteInstance as the current RenderFrameHost. |
| CHECK(proxy_hosts_.find(render_frame_host_->GetSiteInstance()->GetId()) == |
| proxy_hosts_.end()); |
| } |
| |
| void RenderFrameHostManager::ShutdownRenderFrameProxyHostsInSiteInstance( |
| int32 site_instance_id) { |
| // First remove any swapped out RFH for this SiteInstance from our own list. |
| ClearProxiesInSiteInstance(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 |
| // RenderFrameProxyHosts 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. |
| scoped_ptr<RenderWidgetHostIterator> widgets( |
| RenderWidgetHostImpl::GetAllRenderWidgetHosts()); |
| while (RenderWidgetHost* widget = widgets->GetNextHost()) { |
| if (!widget->IsRenderView()) |
| 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::ClearProxiesInSiteInstance, |
| site_instance_id)); |
| } |
| } |
| } |
| |
| RenderFrameHostImpl* RenderFrameHostManager::UpdateStateForNavigate( |
| const GURL& dest_url, |
| SiteInstance* source_instance, |
| SiteInstance* dest_instance, |
| ui::PageTransition transition, |
| bool dest_is_restore, |
| bool dest_is_view_source_mode, |
| const GlobalRequestID& transferred_request_id, |
| int bindings) { |
| // 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_) |
| CancelPending(); |
| cross_navigation_pending_ = false; |
| } |
| |
| SiteInstance* current_instance = render_frame_host_->GetSiteInstance(); |
| scoped_refptr<SiteInstance> new_instance = GetSiteInstanceForNavigation( |
| dest_url, source_instance, dest_instance, transition, |
| dest_is_restore, dest_is_view_source_mode); |
| |
| const NavigationEntry* current_entry = |
| delegate_->GetLastCommittedNavigationEntryForRenderManager(); |
| |
| DCHECK(!cross_navigation_pending_); |
| |
| if (new_instance.get() != current_instance) { |
| TRACE_EVENT_INSTANT2( |
| "navigation", |
| "RenderFrameHostManager::UpdateStateForNavigate:New SiteInstance", |
| TRACE_EVENT_SCOPE_THREAD, |
| "current_instance id", current_instance->GetId(), |
| "new_instance id", new_instance->GetId()); |
| |
| // New SiteInstance: create a pending RFH to navigate. |
| |
| // This will possibly create (set to nullptr) a Web UI object for the |
| // pending page. We'll use this later to give the page special access. This |
| // must happen before the new renderer is created below so it will get |
| // bindings. It must also happen after the above conditional call to |
| // CancelPending(), otherwise CancelPending may clear the pending_web_ui_ |
| // and the page will not have its bindings set appropriately. |
| SetPendingWebUI(dest_url, bindings); |
| CreatePendingRenderFrameHost(current_instance, new_instance.get(), |
| frame_tree_node_->IsMainFrame()); |
| if (!pending_render_frame_host_.get()) { |
| return nullptr; |
| } |
| |
| // Check if our current RFH is live before we set up a transition. |
| if (!render_frame_host_->IsRenderFrameLive()) { |
| 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 |
| // cross-navigating (Note that we don't care about on{before}unload |
| // handlers if the current RFH isn't live.) |
| CommitPending(); |
| return render_frame_host_.get(); |
| } else { |
| NOTREACHED(); |
| return render_frame_host_.get(); |
| } |
| } |
| // Otherwise, it's safe to treat this as a pending cross-site transition. |
| |
| // We now have a pending RFH. |
| DCHECK(!cross_navigation_pending_); |
| cross_navigation_pending_ = true; |
| |
| // We need to wait until the beforeunload handler has run, unless we are |
| // transferring an existing request (in which case it has already run). |
| // Suspend the new render view (i.e., don't let it send the cross-site |
| // 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_->are_navigations_suspended()); |
| bool is_transfer = transferred_request_id != GlobalRequestID(); |
| if (is_transfer) { |
| // We don't need to stop the old renderer or run beforeunload/unload |
| // handlers, because those have already been done. |
| DCHECK(cross_site_transferring_request_->request_id() == |
| transferred_request_id); |
| } else { |
| // 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_->Send(new FrameMsg_Stop( |
| render_frame_host_->GetRoutingID())); |
| pending_render_frame_host_->SetNavigationsSuspended(true, |
| base::TimeTicks()); |
| // Unless we are transferring an existing request, we should now tell the |
| // old render view to run its beforeunload handler, since it doesn't |
| // otherwise know that the cross-site request is happening. This will |
| // trigger a call to OnBeforeUnloadACK with the reply. |
| render_frame_host_->DispatchBeforeUnload(true); |
| } |
| |
| return pending_render_frame_host_.get(); |
| } |
| |
| // Otherwise the same SiteInstance can be used. Navigate render_frame_host_. |
| |
| // It's possible to swap out the current RFH and then decide to navigate in it |
| // anyway (e.g., a cross-process navigation that redirects back to the |
| // original site). In that case, we have a proxy for the current RFH but |
| // haven't deleted it yet. The new navigation will swap it back in, so we can |
| // delete the proxy. |
| DeleteRenderFrameProxyHost(new_instance.get()); |
| |
| if (ShouldReuseWebUI(current_entry, dest_url)) { |
| pending_web_ui_.reset(); |
| pending_and_current_web_ui_ = web_ui_->AsWeakPtr(); |
| } else { |
| SetPendingWebUI(dest_url, bindings); |
| // Make sure the new RenderViewHost has the right bindings. |
| if (pending_web_ui() && |
| !render_frame_host_->GetProcess()->IsIsolatedGuest()) { |
| render_frame_host_->render_view_host()->AllowBindings( |
| pending_web_ui()->GetBindings()); |
| } |
| } |
| |
| if (pending_web_ui() && render_frame_host_->IsRenderFrameLive()) { |
| pending_web_ui()->GetController()->RenderViewReused( |
| render_frame_host_->render_view_host()); |
| } |
| |
| // The renderer can exit view source mode when any error or cancellation |
| // happen. We must overwrite to recover the mode. |
| if (dest_is_view_source_mode) { |
| render_frame_host_->render_view_host()->Send( |
| new ViewMsg_EnableViewSourceMode( |
| render_frame_host_->render_view_host()->GetRoutingID())); |
| } |
| |
| return render_frame_host_.get(); |
| } |
| |
| void RenderFrameHostManager::CancelPending() { |
| TRACE_EVENT1("navigation", "RenderFrameHostManager::CancelPending", |
| "FrameTreeNode id", frame_tree_node_->frame_tree_node_id()); |
| DiscardUnusedFrame(UnsetPendingRenderFrameHost()); |
| } |
| |
| scoped_ptr<RenderFrameHostImpl> |
| RenderFrameHostManager::UnsetPendingRenderFrameHost() { |
| scoped_ptr<RenderFrameHostImpl> pending_render_frame_host = |
| pending_render_frame_host_.Pass(); |
| |
| RenderFrameDevToolsAgentHost::OnCancelPendingNavigation( |
| pending_render_frame_host.get(), |
| render_frame_host_.get()); |
| |
| // We no longer need to prevent the process from exiting. |
| pending_render_frame_host->GetProcess()->RemovePendingView(); |
| |
| pending_web_ui_.reset(); |
| pending_and_current_web_ui_.reset(); |
| |
| return pending_render_frame_host.Pass(); |
| } |
| |
| scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::SetRenderFrameHost( |
| scoped_ptr<RenderFrameHostImpl> render_frame_host) { |
| // Swap the two. |
| scoped_ptr<RenderFrameHostImpl> old_render_frame_host = |
| render_frame_host_.Pass(); |
| render_frame_host_ = render_frame_host.Pass(); |
| |
| if (frame_tree_node_->IsMainFrame()) { |
| // Update the count of top-level frames using this SiteInstance. All |
| // subframes are in the same BrowsingInstance as the main frame, so we only |
| // count top-level ones. This makes the value easier for consumers to |
| // interpret. |
| if (render_frame_host_) { |
| render_frame_host_->GetSiteInstance()-> |
| IncrementRelatedActiveContentsCount(); |
| } |
| if (old_render_frame_host) { |
| old_render_frame_host->GetSiteInstance()-> |
| DecrementRelatedActiveContentsCount(); |
| } |
| } |
| |
| return old_render_frame_host.Pass(); |
| } |
| |
| bool RenderFrameHostManager::IsRVHOnSwappedOutList( |
| RenderViewHostImpl* rvh) const { |
| RenderFrameProxyHost* proxy = GetRenderFrameProxyHost( |
| rvh->GetSiteInstance()); |
| if (!proxy) |
| return false; |
| // If there is a proxy without RFH, it is for a subframe in the SiteInstance |
| // of |rvh|. Subframes should be ignored in this case. |
| if (!proxy->render_frame_host()) |
| return false; |
| return IsOnSwappedOutList(proxy->render_frame_host()); |
| } |
| |
| bool RenderFrameHostManager::IsOnSwappedOutList( |
| RenderFrameHostImpl* rfh) const { |
| if (!rfh->GetSiteInstance()) |
| return false; |
| |
| RenderFrameProxyHostMap::const_iterator iter = proxy_hosts_.find( |
| rfh->GetSiteInstance()->GetId()); |
| if (iter == proxy_hosts_.end()) |
| return false; |
| |
| return iter->second->render_frame_host() == rfh; |
| } |
| |
| RenderViewHostImpl* RenderFrameHostManager::GetSwappedOutRenderViewHost( |
| SiteInstance* instance) const { |
| RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance); |
| if (proxy) |
| return proxy->GetRenderViewHost(); |
| return NULL; |
| } |
| |
| RenderFrameProxyHost* RenderFrameHostManager::GetRenderFrameProxyHost( |
| SiteInstance* instance) const { |
| RenderFrameProxyHostMap::const_iterator iter = |
| proxy_hosts_.find(instance->GetId()); |
| if (iter != proxy_hosts_.end()) |
| return iter->second; |
| |
| return NULL; |
| } |
| |
| void RenderFrameHostManager::DeleteRenderFrameProxyHost( |
| SiteInstance* instance) { |
| RenderFrameProxyHostMap::iterator iter = proxy_hosts_.find(instance->GetId()); |
| if (iter != proxy_hosts_.end()) { |
| delete iter->second; |
| proxy_hosts_.erase(iter); |
| } |
| } |
| |
| } // namespace content |