OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/frame_host/render_frame_host_manager.h" | 5 #include "content/browser/frame_host/render_frame_host_manager.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/command_line.h" | 9 #include "base/command_line.h" |
10 #include "base/debug/trace_event.h" | 10 #include "base/debug/trace_event.h" |
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
127 ->render_manager() | 127 ->render_manager() |
128 ->current_frame_host() | 128 ->current_frame_host() |
129 ->GetSiteInstance() | 129 ->GetSiteInstance() |
130 ->GetId()); | 130 ->GetId()); |
131 if (iter == proxy_hosts_.end()) | 131 if (iter == proxy_hosts_.end()) |
132 return NULL; | 132 return NULL; |
133 | 133 |
134 return iter->second; | 134 return iter->second; |
135 } | 135 } |
136 | 136 |
137 void RenderFrameHostManager::SetPendingWebUI(const GURL& url, | 137 void RenderFrameHostManager::SetPendingWebUI(const GURL& url, int bindings) { |
138 int bindings) { | 138 pending_web_ui_.reset(CreateWebUI(url, bindings)); |
139 pending_web_ui_.reset( | |
140 delegate_->CreateWebUIForRenderManager(url)); | |
141 pending_and_current_web_ui_.reset(); | 139 pending_and_current_web_ui_.reset(); |
140 } | |
141 | |
142 WebUIImpl* RenderFrameHostManager::CreateWebUI(const GURL& url, int bindings) { | |
143 WebUIImpl* new_web_ui = delegate_->CreateWebUIForRenderManager(url); | |
142 | 144 |
143 // If we have assigned (zero or more) bindings to this NavigationEntry in the | 145 // If we have assigned (zero or more) bindings to this NavigationEntry in the |
144 // past, make sure we're not granting it different bindings than it had | 146 // past, make sure we're not granting it different bindings than it had |
145 // before. If so, note it and don't give it any bindings, to avoid a | 147 // before. If so, note it and don't give it any bindings, to avoid a |
146 // potential privilege escalation. | 148 // potential privilege escalation. |
147 if (pending_web_ui_.get() && | 149 if (new_web_ui && bindings != NavigationEntryImpl::kInvalidBindings && |
148 bindings != NavigationEntryImpl::kInvalidBindings && | 150 new_web_ui->GetBindings() != bindings) { |
149 pending_web_ui_->GetBindings() != bindings) { | 151 RecordAction(base::UserMetricsAction("ProcessSwapBindingsMismatch_RVHM")); |
150 RecordAction( | 152 delete new_web_ui; |
151 base::UserMetricsAction("ProcessSwapBindingsMismatch_RVHM")); | 153 return nullptr; |
152 pending_web_ui_.reset(); | |
153 } | 154 } |
155 return new_web_ui; | |
154 } | 156 } |
155 | 157 |
156 RenderFrameHostImpl* RenderFrameHostManager::Navigate( | 158 RenderFrameHostImpl* RenderFrameHostManager::Navigate( |
157 const NavigationEntryImpl& entry) { | 159 const NavigationEntryImpl& entry) { |
158 TRACE_EVENT1("navigation", "RenderFrameHostManager:Navigate", | 160 TRACE_EVENT1("navigation", "RenderFrameHostManager:Navigate", |
159 "FrameTreeNode id", frame_tree_node_->frame_tree_node_id()); | 161 "FrameTreeNode id", frame_tree_node_->frame_tree_node_id()); |
160 // Create a pending RenderFrameHost to use for the navigation. | 162 // Create a pending RenderFrameHost to use for the navigation. |
161 RenderFrameHostImpl* dest_render_frame_host = UpdateStateForNavigate( | 163 RenderFrameHostImpl* dest_render_frame_host = UpdateStateForNavigate( |
162 entry.GetURL(), | 164 entry.GetURL(), |
163 entry.site_instance(), | 165 entry.site_instance(), |
(...skipping 386 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
550 // We shouldn't get here for subframes, since we only swap subframes when | 552 // We shouldn't get here for subframes, since we only swap subframes when |
551 // --site-per-process is used. | 553 // --site-per-process is used. |
552 DCHECK(is_main_frame); | 554 DCHECK(is_main_frame); |
553 | 555 |
554 // The old RenderFrameHost will stay alive inside the proxy so that existing | 556 // The old RenderFrameHost will stay alive inside the proxy so that existing |
555 // JavaScript window references to it stay valid. | 557 // JavaScript window references to it stay valid. |
556 proxy->TakeFrameHostOwnership(old_render_frame_host.Pass()); | 558 proxy->TakeFrameHostOwnership(old_render_frame_host.Pass()); |
557 } | 559 } |
558 } | 560 } |
559 | 561 |
562 void RenderFrameHostManager::DiscardRenderFrameHost( | |
nasko
2014/11/24 23:59:08
Now that I think about it more, I'm not sure why a
carlosk
2014/11/25 10:54:30
The same thing is done for non-utilized pending RF
nasko
2014/11/26 00:13:02
One thing is clear, we don't need to call rfh->Swa
carlosk
2014/11/27 11:02:43
Acknowledged.
| |
563 scoped_ptr<RenderFrameHostImpl> render_frame_host) { | |
564 // TODO(carlosk): this code is very similar to what can be found in | |
565 // SwapOutOldFrame and we should see that these are unified at some point. | |
566 | |
567 // If the SiteInstance for the pending RFH is being used by others, don't | |
568 // delete the RFH, just swap it out and it can be reused at a later point. | |
569 SiteInstanceImpl* site_instance = render_frame_host->GetSiteInstance(); | |
570 if (site_instance->HasSite() && site_instance->active_frame_count() > 1) { | |
571 // Any currently suspended navigations are no longer needed. | |
572 render_frame_host->CancelSuspendedNavigations(); | |
573 | |
574 RenderFrameProxyHost* proxy = | |
575 new RenderFrameProxyHost(site_instance, frame_tree_node_); | |
576 proxy_hosts_[site_instance->GetId()] = proxy; | |
577 render_frame_host->SwapOut(proxy); | |
578 if (frame_tree_node_->IsMainFrame()) | |
579 proxy->TakeFrameHostOwnership(render_frame_host.Pass()); | |
580 } else { | |
581 // We won't be coming back, so delete this one. | |
582 render_frame_host.reset(); | |
583 } | |
584 } | |
585 | |
560 void RenderFrameHostManager::MoveToPendingDeleteHosts( | 586 void RenderFrameHostManager::MoveToPendingDeleteHosts( |
561 scoped_ptr<RenderFrameHostImpl> render_frame_host) { | 587 scoped_ptr<RenderFrameHostImpl> render_frame_host) { |
562 // |render_frame_host| will be deleted when its SwapOut ACK is received, or | 588 // |render_frame_host| will be deleted when its SwapOut ACK is received, or |
563 // when the timer times out, or when the RFHM itself is deleted (whichever | 589 // when the timer times out, or when the RFHM itself is deleted (whichever |
564 // comes first). | 590 // comes first). |
565 pending_delete_hosts_.push_back( | 591 pending_delete_hosts_.push_back( |
566 linked_ptr<RenderFrameHostImpl>(render_frame_host.release())); | 592 linked_ptr<RenderFrameHostImpl>(render_frame_host.release())); |
567 } | 593 } |
568 | 594 |
569 bool RenderFrameHostManager::IsPendingDeletion( | 595 bool RenderFrameHostManager::IsPendingDeletion( |
(...skipping 420 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
990 return current_instance->GetSiteURL(); | 1016 return current_instance->GetSiteURL(); |
991 } | 1017 } |
992 | 1018 |
993 void RenderFrameHostManager::CreateRenderFrameHostForNewSiteInstance( | 1019 void RenderFrameHostManager::CreateRenderFrameHostForNewSiteInstance( |
994 SiteInstance* old_instance, | 1020 SiteInstance* old_instance, |
995 SiteInstance* new_instance, | 1021 SiteInstance* new_instance, |
996 bool is_main_frame) { | 1022 bool is_main_frame) { |
997 int create_render_frame_flags = 0; | 1023 int create_render_frame_flags = 0; |
998 if (is_main_frame) | 1024 if (is_main_frame) |
999 create_render_frame_flags |= CREATE_RF_FOR_MAIN_FRAME_NAVIGATION; | 1025 create_render_frame_flags |= CREATE_RF_FOR_MAIN_FRAME_NAVIGATION; |
1000 // Ensure that we have created RFHs for the new RFH's opener chain if | 1026 |
1001 // we are staying in the same BrowsingInstance. This allows the new RFH | 1027 if (delegate_->IsHidden()) |
1002 // to send cross-process script calls to its opener(s). | 1028 create_render_frame_flags |= CREATE_RF_HIDDEN; |
1029 | |
1030 int opener_route_id = | |
1031 CreateOpenerRenderViewsIfNeeded(old_instance, new_instance); | |
1032 // TODO(carlosk): does this "earlier" call for CancelPending affects anything? | |
nasko
2014/11/24 23:59:08
I didn't add the same comment about empty line to
carlosk
2014/11/25 10:54:30
Acknowledged and done.
| |
1033 // It used to happen inside the creation method iff the new RFH was | |
1034 // successfully created. | |
carlosk
2014/11/25 10:54:30
I'm also removing this TODO here. My testing showe
| |
1035 if (pending_render_frame_host_) | |
1036 CancelPending(); | |
1037 // Create a non-swapped-out RFH with the given opener. | |
1038 pending_render_frame_host_ = | |
1039 CreateRenderFrame(new_instance, opener_route_id, | |
1040 create_render_frame_flags, pending_web_ui(), nullptr); | |
1041 } | |
1042 | |
1043 int RenderFrameHostManager::CreateOpenerRenderViewsIfNeeded( | |
1044 SiteInstance* old_instance, | |
1045 SiteInstance* new_instance) { | |
1003 int opener_route_id = MSG_ROUTING_NONE; | 1046 int opener_route_id = MSG_ROUTING_NONE; |
1004 if (new_instance->IsRelatedSiteInstance(old_instance)) { | 1047 if (new_instance->IsRelatedSiteInstance(old_instance)) { |
1005 opener_route_id = | 1048 opener_route_id = |
1006 delegate_->CreateOpenerRenderViewsForRenderManager(new_instance); | 1049 delegate_->CreateOpenerRenderViewsForRenderManager(new_instance); |
1007 if (CommandLine::ForCurrentProcess()->HasSwitch( | 1050 if (CommandLine::ForCurrentProcess()->HasSwitch( |
1008 switches::kSitePerProcess)) { | 1051 switches::kSitePerProcess)) { |
1009 // Ensure that the frame tree has RenderFrameProxyHosts for the new | 1052 // Ensure that the frame tree has RenderFrameProxyHosts for the new |
1010 // SiteInstance in all nodes except the current one. | 1053 // SiteInstance in all nodes except the current one. |
1011 frame_tree_node_->frame_tree()->CreateProxiesForSiteInstance( | 1054 frame_tree_node_->frame_tree()->CreateProxiesForSiteInstance( |
1012 frame_tree_node_, new_instance); | 1055 frame_tree_node_, new_instance); |
1013 } | 1056 } |
1014 } | 1057 } |
1015 | 1058 return opener_route_id; |
1016 if (delegate_->IsHidden()) | |
1017 create_render_frame_flags |= CREATE_RF_HIDDEN; | |
1018 | |
1019 // Create a non-swapped-out RFH with the given opener. | |
1020 int route_id = CreateRenderFrame(new_instance, opener_route_id, | |
1021 create_render_frame_flags); | |
1022 if (route_id == MSG_ROUTING_NONE) { | |
1023 pending_render_frame_host_.reset(); | |
1024 return; | |
1025 } | |
1026 } | 1059 } |
1027 | 1060 |
1028 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrameHost( | 1061 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrameHost( |
1029 SiteInstance* site_instance, | 1062 SiteInstance* site_instance, |
1030 int view_routing_id, | 1063 int view_routing_id, |
1031 int frame_routing_id, | 1064 int frame_routing_id, |
1032 int flags) { | 1065 int flags) { |
1033 if (frame_routing_id == MSG_ROUTING_NONE) | 1066 if (frame_routing_id == MSG_ROUTING_NONE) |
1034 frame_routing_id = site_instance->GetProcess()->GetNextRoutingID(); | 1067 frame_routing_id = site_instance->GetProcess()->GetNextRoutingID(); |
1035 | 1068 |
(...skipping 13 matching lines...) Expand all Loading... | |
1049 } | 1082 } |
1050 | 1083 |
1051 // TODO(creis): Pass hidden to RFH. | 1084 // TODO(creis): Pass hidden to RFH. |
1052 scoped_ptr<RenderFrameHostImpl> render_frame_host = | 1085 scoped_ptr<RenderFrameHostImpl> render_frame_host = |
1053 make_scoped_ptr(RenderFrameHostFactory::Create( | 1086 make_scoped_ptr(RenderFrameHostFactory::Create( |
1054 render_view_host, render_frame_delegate_, frame_tree, | 1087 render_view_host, render_frame_delegate_, frame_tree, |
1055 frame_tree_node_, frame_routing_id, flags).release()); | 1088 frame_tree_node_, frame_routing_id, flags).release()); |
1056 return render_frame_host.Pass(); | 1089 return render_frame_host.Pass(); |
1057 } | 1090 } |
1058 | 1091 |
1059 int RenderFrameHostManager::CreateRenderFrame(SiteInstance* instance, | 1092 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrame( |
1060 int opener_route_id, | 1093 SiteInstance* instance, |
1061 int flags) { | 1094 int opener_route_id, |
1095 int flags, | |
1096 const WebUIImpl* web_ui, | |
1097 int* routing_id_ptr) { | |
1062 bool swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT); | 1098 bool swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT); |
1063 CHECK(instance); | 1099 CHECK(instance); |
1064 // Swapped out views should always be hidden. | 1100 // Swapped out views should always be hidden. |
1065 DCHECK(!swapped_out || (flags & CREATE_RF_HIDDEN)); | 1101 DCHECK(!swapped_out || (flags & CREATE_RF_HIDDEN)); |
1066 | 1102 |
1067 // TODO(nasko): Remove the following CHECK once cross-site navigation no | 1103 // TODO(nasko): Remove the following CHECK once cross-site navigation no |
1068 // longer relies on swapped out RFH for the top-level frame. | 1104 // longer relies on swapped out RFH for the top-level frame. |
1069 if (!frame_tree_node_->IsMainFrame()) { | 1105 if (!frame_tree_node_->IsMainFrame()) { |
1070 CHECK(!swapped_out); | 1106 CHECK(!swapped_out); |
1071 } | 1107 } |
1072 | 1108 |
1073 scoped_ptr<RenderFrameHostImpl> new_render_frame_host; | 1109 scoped_ptr<RenderFrameHostImpl> new_render_frame_host; |
1074 RenderFrameHostImpl* frame_to_announce = NULL; | 1110 bool success = true; |
nasko
2014/11/24 23:59:08
Why do you need to pre-declare success here? It is
carlosk
2014/11/25 10:54:30
It's also used in the last top-level if-block to d
| |
1075 int routing_id = MSG_ROUTING_NONE; | 1111 if (routing_id_ptr) |
1112 *routing_id_ptr = MSG_ROUTING_NONE; | |
1076 | 1113 |
1077 // We are creating a pending or swapped out RFH here. We should never create | 1114 // We are creating a pending or swapped out RFH here. We should never create |
1078 // it in the same SiteInstance as our current RFH. | 1115 // it in the same SiteInstance as our current RFH. |
1079 CHECK_NE(render_frame_host_->GetSiteInstance(), instance); | 1116 CHECK_NE(render_frame_host_->GetSiteInstance(), instance); |
1080 | 1117 |
1081 // Check if we've already created an RFH for this SiteInstance. If so, try | 1118 // Check if we've already created an RFH for this SiteInstance. If so, try |
1082 // to re-use the existing one, which has already been initialized. We'll | 1119 // to re-use the existing one, which has already been initialized. We'll |
1083 // remove it from the list of proxy hosts below if it will be active. | 1120 // remove it from the list of proxy hosts below if it will be active. |
1084 RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance); | 1121 RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance); |
1085 | |
1086 if (proxy && proxy->render_frame_host()) { | 1122 if (proxy && proxy->render_frame_host()) { |
1087 routing_id = proxy->GetRenderViewHost()->GetRoutingID(); | 1123 if (routing_id_ptr) |
1124 *routing_id_ptr = proxy->GetRenderViewHost()->GetRoutingID(); | |
1088 // Delete the existing RenderFrameProxyHost, but reuse the RenderFrameHost. | 1125 // Delete the existing RenderFrameProxyHost, but reuse the RenderFrameHost. |
1089 // Prevent the process from exiting while we're trying to use it. | 1126 // Prevent the process from exiting while we're trying to use it. |
1090 if (!swapped_out) { | 1127 if (!swapped_out) { |
1091 new_render_frame_host = proxy->PassFrameHostOwnership(); | 1128 new_render_frame_host = proxy->PassFrameHostOwnership(); |
1092 new_render_frame_host->GetProcess()->AddPendingView(); | 1129 new_render_frame_host->GetProcess()->AddPendingView(); |
1093 | 1130 |
1094 proxy_hosts_.erase(instance->GetId()); | 1131 proxy_hosts_.erase(instance->GetId()); |
1095 delete proxy; | 1132 delete proxy; |
1096 | 1133 |
1097 // When a new render view is created by the renderer, the new WebContents | 1134 // When a new render view is created by the renderer, the new WebContents |
1098 // gets a RenderViewHost in the SiteInstance of its opener WebContents. | 1135 // gets a RenderViewHost in the SiteInstance of its opener WebContents. |
1099 // If not used in the first navigation, this RVH is swapped out and is not | 1136 // If not used in the first navigation, this RVH is swapped out and is not |
1100 // granted bindings, so we may need to grant them when swapping it in. | 1137 // granted bindings, so we may need to grant them when swapping it in. |
1101 if (pending_web_ui() && | 1138 if (web_ui && !new_render_frame_host->GetProcess()->IsIsolatedGuest()) { |
1102 !new_render_frame_host->GetProcess()->IsIsolatedGuest()) { | 1139 int required_bindings = web_ui->GetBindings(); |
1103 int required_bindings = pending_web_ui()->GetBindings(); | 1140 RenderViewHost* render_view_host = |
1104 RenderViewHost* rvh = new_render_frame_host->render_view_host(); | 1141 new_render_frame_host->render_view_host(); |
1105 if ((rvh->GetEnabledBindings() & required_bindings) != | 1142 if ((render_view_host->GetEnabledBindings() & required_bindings) != |
1106 required_bindings) { | 1143 required_bindings) { |
1107 rvh->AllowBindings(required_bindings); | 1144 render_view_host->AllowBindings(required_bindings); |
1108 } | 1145 } |
1109 } | 1146 } |
1110 } | 1147 } |
1111 } else { | 1148 } else { |
1112 // Create a new RenderFrameHost if we don't find an existing one. | 1149 // Create a new RenderFrameHost if we don't find an existing one. |
1113 new_render_frame_host = CreateRenderFrameHost(instance, MSG_ROUTING_NONE, | 1150 new_render_frame_host = CreateRenderFrameHost(instance, MSG_ROUTING_NONE, |
1114 MSG_ROUTING_NONE, flags); | 1151 MSG_ROUTING_NONE, flags); |
1115 RenderViewHostImpl* render_view_host = | 1152 RenderViewHostImpl* render_view_host = |
1116 new_render_frame_host->render_view_host(); | 1153 new_render_frame_host->render_view_host(); |
1117 int proxy_routing_id = MSG_ROUTING_NONE; | 1154 int proxy_routing_id = MSG_ROUTING_NONE; |
1118 | 1155 |
1119 // Prevent the process from exiting while we're trying to navigate in it. | 1156 // Prevent the process from exiting while we're trying to navigate in it. |
1120 // Otherwise, if the new RFH is swapped out already, store it. | 1157 // Otherwise, if the new RFH is swapped out already, store it. |
1121 if (!swapped_out) { | 1158 if (!swapped_out) { |
1122 new_render_frame_host->GetProcess()->AddPendingView(); | 1159 new_render_frame_host->GetProcess()->AddPendingView(); |
1123 } else { | 1160 } else { |
1124 proxy = new RenderFrameProxyHost( | 1161 proxy = new RenderFrameProxyHost( |
1125 new_render_frame_host->GetSiteInstance(), frame_tree_node_); | 1162 new_render_frame_host->GetSiteInstance(), frame_tree_node_); |
1126 proxy_hosts_[instance->GetId()] = proxy; | 1163 proxy_hosts_[instance->GetId()] = proxy; |
1127 proxy_routing_id = proxy->GetRoutingID(); | 1164 proxy_routing_id = proxy->GetRoutingID(); |
1128 if (frame_tree_node_->IsMainFrame()) | 1165 if (frame_tree_node_->IsMainFrame()) |
1129 proxy->TakeFrameHostOwnership(new_render_frame_host.Pass()); | 1166 proxy->TakeFrameHostOwnership(new_render_frame_host.Pass()); |
1130 } | 1167 } |
1131 | 1168 |
1132 bool success = | 1169 success = |
1133 InitRenderView(render_view_host, opener_route_id, proxy_routing_id, | 1170 InitRenderView(render_view_host, opener_route_id, proxy_routing_id, |
1134 !!(flags & CREATE_RF_FOR_MAIN_FRAME_NAVIGATION)); | 1171 !!(flags & CREATE_RF_FOR_MAIN_FRAME_NAVIGATION)); |
1135 if (success) { | 1172 if (success) { |
1136 if (frame_tree_node_->IsMainFrame()) { | 1173 if (frame_tree_node_->IsMainFrame()) { |
1137 // Don't show the main frame's view until we get a DidNavigate from it. | 1174 // Don't show the main frame's view until we get a DidNavigate from it. |
1138 render_view_host->GetView()->Hide(); | 1175 render_view_host->GetView()->Hide(); |
1139 } else if (!swapped_out) { | 1176 } else if (!swapped_out) { |
1140 // Init the RFH, so a RenderFrame is created in the renderer. | 1177 // Init the RFH, so a RenderFrame is created in the renderer. |
1141 DCHECK(new_render_frame_host.get()); | 1178 DCHECK(new_render_frame_host.get()); |
1142 success = InitRenderFrame(new_render_frame_host.get()); | 1179 success = InitRenderFrame(new_render_frame_host.get()); |
1143 } | 1180 } |
1144 } else if (!swapped_out && pending_render_frame_host_) { | 1181 if (success) { |
1145 CancelPending(); | 1182 if (routing_id_ptr) |
1183 *routing_id_ptr = render_view_host->GetRoutingID(); | |
1184 // If a brand new RFH was created, announce it to observers. | |
1185 // TODO(carlosk): verify there's no problem that now this RFH will only | |
nasko
2014/11/24 23:59:08
Let's verify this TODO before committing this code
carlosk
2014/11/25 10:54:30
Yes. For this case I found no problems in any of m
| |
1186 // be set as the pending one *after* this delegate call (used to be | |
1187 // before). | |
1188 if (new_render_frame_host) { | |
1189 render_frame_delegate_->RenderFrameCreated( | |
1190 new_render_frame_host.get()); | |
1191 } | |
1192 } | |
1146 } | 1193 } |
1147 routing_id = render_view_host->GetRoutingID(); | |
1148 frame_to_announce = new_render_frame_host.get(); | |
1149 } | 1194 } |
1150 | 1195 |
1151 // Use this as our new pending RFH if it isn't swapped out. | 1196 // Returns the new RFH if it isn't swapped out. |
1152 if (!swapped_out) | 1197 if (success && !swapped_out) { |
nasko
2014/11/24 23:59:08
Why not return always if new_render_frame_host is
carlosk
2014/11/25 10:54:30
Because of line 1179. If that one fails new_render
| |
1153 pending_render_frame_host_ = new_render_frame_host.Pass(); | 1198 DCHECK(new_render_frame_host->GetSiteInstance() == instance); |
1154 | 1199 return new_render_frame_host.Pass(); |
1155 // If a brand new RFH was created, announce it to observers. | 1200 } |
1156 if (frame_to_announce) | 1201 return nullptr; |
1157 render_frame_delegate_->RenderFrameCreated(frame_to_announce); | |
1158 | |
1159 return routing_id; | |
1160 } | 1202 } |
1161 | 1203 |
1162 int RenderFrameHostManager::CreateRenderFrameProxy(SiteInstance* instance) { | 1204 int RenderFrameHostManager::CreateRenderFrameProxy(SiteInstance* instance) { |
1163 // A RenderFrameProxyHost should never be created in the same SiteInstance as | 1205 // A RenderFrameProxyHost should never be created in the same SiteInstance as |
1164 // the current RFH. | 1206 // the current RFH. |
1165 CHECK(instance); | 1207 CHECK(instance); |
1166 CHECK_NE(instance, render_frame_host_->GetSiteInstance()); | 1208 CHECK_NE(instance, render_frame_host_->GetSiteInstance()); |
1167 | 1209 |
1168 RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance); | 1210 RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance); |
1169 if (proxy) | 1211 if (proxy) |
(...skipping 381 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1551 scoped_ptr<RenderFrameHostImpl> pending_render_frame_host = | 1593 scoped_ptr<RenderFrameHostImpl> pending_render_frame_host = |
1552 pending_render_frame_host_.Pass(); | 1594 pending_render_frame_host_.Pass(); |
1553 | 1595 |
1554 RenderViewDevToolsAgentHost::OnCancelPendingNavigation( | 1596 RenderViewDevToolsAgentHost::OnCancelPendingNavigation( |
1555 pending_render_frame_host->render_view_host(), | 1597 pending_render_frame_host->render_view_host(), |
1556 render_frame_host_->render_view_host()); | 1598 render_frame_host_->render_view_host()); |
1557 | 1599 |
1558 // We no longer need to prevent the process from exiting. | 1600 // We no longer need to prevent the process from exiting. |
1559 pending_render_frame_host->GetProcess()->RemovePendingView(); | 1601 pending_render_frame_host->GetProcess()->RemovePendingView(); |
1560 | 1602 |
1561 // If the SiteInstance for the pending RFH is being used by others, don't | 1603 DiscardRenderFrameHost(pending_render_frame_host.Pass()); |
1562 // delete the RFH, just swap it out and it can be reused at a later point. | |
1563 SiteInstanceImpl* site_instance = | |
1564 pending_render_frame_host->GetSiteInstance(); | |
1565 if (site_instance->active_frame_count() > 1) { | |
1566 // Any currently suspended navigations are no longer needed. | |
1567 pending_render_frame_host->CancelSuspendedNavigations(); | |
1568 | |
1569 RenderFrameProxyHost* proxy = | |
1570 new RenderFrameProxyHost(site_instance, frame_tree_node_); | |
1571 proxy_hosts_[site_instance->GetId()] = proxy; | |
1572 pending_render_frame_host->SwapOut(proxy); | |
1573 if (frame_tree_node_->IsMainFrame()) | |
1574 proxy->TakeFrameHostOwnership(pending_render_frame_host.Pass()); | |
1575 } else { | |
1576 // We won't be coming back, so delete this one. | |
1577 pending_render_frame_host.reset(); | |
1578 } | |
1579 | 1604 |
1580 pending_web_ui_.reset(); | 1605 pending_web_ui_.reset(); |
1581 pending_and_current_web_ui_.reset(); | 1606 pending_and_current_web_ui_.reset(); |
1582 } | 1607 } |
1583 | 1608 |
1584 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::SetRenderFrameHost( | 1609 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::SetRenderFrameHost( |
1585 scoped_ptr<RenderFrameHostImpl> render_frame_host) { | 1610 scoped_ptr<RenderFrameHostImpl> render_frame_host) { |
1586 // Swap the two. | 1611 // Swap the two. |
1587 scoped_ptr<RenderFrameHostImpl> old_render_frame_host = | 1612 scoped_ptr<RenderFrameHostImpl> old_render_frame_host = |
1588 render_frame_host_.Pass(); | 1613 render_frame_host_.Pass(); |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1653 void RenderFrameHostManager::DeleteRenderFrameProxyHost( | 1678 void RenderFrameHostManager::DeleteRenderFrameProxyHost( |
1654 SiteInstance* instance) { | 1679 SiteInstance* instance) { |
1655 RenderFrameProxyHostMap::iterator iter = proxy_hosts_.find(instance->GetId()); | 1680 RenderFrameProxyHostMap::iterator iter = proxy_hosts_.find(instance->GetId()); |
1656 if (iter != proxy_hosts_.end()) { | 1681 if (iter != proxy_hosts_.end()) { |
1657 delete iter->second; | 1682 delete iter->second; |
1658 proxy_hosts_.erase(iter); | 1683 proxy_hosts_.erase(iter); |
1659 } | 1684 } |
1660 } | 1685 } |
1661 | 1686 |
1662 } // namespace content | 1687 } // namespace content |
OLD | NEW |