OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "chrome/browser/prerender/prerender_manager.h" | 5 #include "chrome/browser/prerender/prerender_manager.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <functional> | 8 #include <functional> |
9 #include <string> | 9 #include <string> |
10 #include <vector> | 10 #include <vector> |
(...skipping 194 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
205 | 205 |
206 PrerenderManager::~PrerenderManager() { | 206 PrerenderManager::~PrerenderManager() { |
207 } | 207 } |
208 | 208 |
209 void PrerenderManager::Shutdown() { | 209 void PrerenderManager::Shutdown() { |
210 DoShutdown(); | 210 DoShutdown(); |
211 } | 211 } |
212 | 212 |
213 PrerenderHandle* PrerenderManager::AddPrerenderFromLinkRelPrerender( | 213 PrerenderHandle* PrerenderManager::AddPrerenderFromLinkRelPrerender( |
214 int process_id, | 214 int process_id, |
215 int prerender_id, | |
215 int route_id, | 216 int route_id, |
216 const GURL& url, | 217 const GURL& url, |
217 const content::Referrer& referrer, | 218 const content::Referrer& referrer, |
218 const gfx::Size& size) { | 219 const gfx::Size& size) { |
219 #if defined(OS_ANDROID) | 220 #if defined(OS_ANDROID) |
220 // TODO(jcivelli): http://crbug.com/113322 We should have an option to disable | 221 // TODO(jcivelli): http://crbug.com/113322 We should have an option to disable |
221 // link-prerender and enable omnibox-prerender only. | 222 // link-prerender and enable omnibox-prerender only. |
222 return NULL; | 223 return NULL; |
223 #else | 224 #else |
224 DCHECK(!size.IsEmpty()); | 225 DCHECK(!size.IsEmpty()); |
225 if (PrerenderData* parent_prerender_data = | 226 if (PrerenderData* parent_prerender_data = |
226 FindPrerenderDataForChildAndRoute(process_id, route_id)) { | 227 FindPrerenderDataForChildAndRoute(process_id, route_id)) { |
227 // Instead of prerendering from inside of a running prerender, we will defer | 228 // Instead of prerendering from inside of a running prerender, we will defer |
228 // this request until its launcher is made visible. | 229 // this request until its launcher is made visible. |
229 if (PrerenderContents* contents = parent_prerender_data->contents_) { | 230 if (PrerenderContents* contents = parent_prerender_data->contents_) { |
230 pending_prerender_list_.push_back( | 231 pending_prerender_list_.push_back(linked_ptr<PrerenderData>( |
231 linked_ptr<PrerenderData>(new PrerenderData(this))); | 232 new PrerenderData(this))); |
232 PrerenderHandle* prerender_handle = | 233 PrerenderHandle* prerender_handle = |
233 new PrerenderHandle(pending_prerender_list_.back().get()); | 234 new PrerenderHandle(pending_prerender_list_.back().get()); |
234 contents->AddPendingPrerender( | 235 contents->AddPendingPrerender( |
235 prerender_handle->weak_ptr_factory_.GetWeakPtr(), | 236 prerender_handle->weak_ptr_factory_.GetWeakPtr(), |
236 url, referrer, size); | 237 url, referrer, size); |
237 return prerender_handle; | 238 return prerender_handle; |
238 } | 239 } |
239 } | 240 } |
240 | 241 |
241 // Unit tests pass in a process_id == -1. | 242 // Unit tests pass in a process_id == -1. |
242 SessionStorageNamespace* session_storage_namespace = NULL; | 243 SessionStorageNamespace* session_storage_namespace = NULL; |
243 if (process_id != -1) { | 244 if (process_id != -1) { |
244 RenderViewHost* source_render_view_host = | 245 RenderViewHost* source_render_view_host = |
245 RenderViewHost::FromID(process_id, route_id); | 246 RenderViewHost::FromID(process_id, route_id); |
246 if (!source_render_view_host) | 247 if (!source_render_view_host) |
247 return NULL; | 248 return NULL; |
248 WebContents* source_web_contents = | 249 WebContents* source_web_contents = |
249 WebContents::FromRenderViewHost(source_render_view_host); | 250 WebContents::FromRenderViewHost(source_render_view_host); |
250 if (!source_web_contents) | 251 if (!source_web_contents) |
251 return NULL; | 252 return NULL; |
252 // TODO(ajwong): This does not correctly handle storage for isolated apps. | 253 // TODO(ajwong): This does not correctly handle storage for isolated apps. |
253 session_storage_namespace = | 254 session_storage_namespace = |
254 source_web_contents->GetController() | 255 source_web_contents->GetController() |
255 .GetDefaultSessionStorageNamespace(); | 256 .GetDefaultSessionStorageNamespace(); |
256 } | 257 } |
257 | 258 |
258 return AddPrerender(ORIGIN_LINK_REL_PRERENDER, | 259 return AddPrerender(ORIGIN_LINK_REL_PRERENDER, |
259 process_id, url, referrer, size, | 260 process_id, prerender_id, url, referrer, size, |
dominich
2012/09/12 15:21:04
I thought the PrerenderHandle work would remove th
| |
260 session_storage_namespace); | 261 session_storage_namespace); |
261 #endif | 262 #endif |
262 } | 263 } |
263 | 264 |
264 PrerenderHandle* PrerenderManager::AddPrerenderFromOmnibox( | 265 PrerenderHandle* PrerenderManager::AddPrerenderFromOmnibox( |
265 const GURL& url, | 266 const GURL& url, |
266 SessionStorageNamespace* session_storage_namespace, | 267 SessionStorageNamespace* session_storage_namespace, |
267 const gfx::Size& size) { | 268 const gfx::Size& size) { |
268 if (!IsOmniboxEnabled(profile_)) | 269 if (!IsOmniboxEnabled(profile_)) |
269 return NULL; | 270 return NULL; |
270 return AddPrerender(ORIGIN_OMNIBOX, -1, url, content::Referrer(), size, | 271 return AddPrerender(ORIGIN_OMNIBOX, -1, -1, url, content::Referrer(), size, |
dominich
2012/09/12 15:21:04
does this mean the renderer doesn't get informed a
| |
271 session_storage_namespace); | 272 session_storage_namespace); |
272 } | 273 } |
273 | 274 |
274 void PrerenderManager::DestroyPrerenderForRenderView( | 275 void PrerenderManager::DestroyPrerenderForRenderView( |
275 int process_id, int view_id, FinalStatus final_status) { | 276 int process_id, int view_id, FinalStatus final_status) { |
276 DCHECK(CalledOnValidThread()); | 277 DCHECK(CalledOnValidThread()); |
277 if (PrerenderData* prerender_data = | 278 if (PrerenderData* prerender_data = |
278 FindPrerenderDataForChildAndRoute(process_id, view_id)) { | 279 FindPrerenderDataForChildAndRoute(process_id, view_id)) { |
279 prerender_data->contents_->Destroy(final_status); | 280 prerender_data->contents_->Destroy(final_status); |
280 } | 281 } |
(...skipping 542 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
823 DCHECK(existing_prerender_handle->IsValid()); | 824 DCHECK(existing_prerender_handle->IsValid()); |
824 DCHECK(existing_prerender_handle->IsPending()); | 825 DCHECK(existing_prerender_handle->IsPending()); |
825 | 826 |
826 DVLOG(6) << "StartPendingPrerender"; | 827 DVLOG(6) << "StartPendingPrerender"; |
827 DVLOG(6) << "existing_prerender_handle->handle_count_ = " << | 828 DVLOG(6) << "existing_prerender_handle->handle_count_ = " << |
828 existing_prerender_handle->prerender_data_->handle_count_; | 829 existing_prerender_handle->prerender_data_->handle_count_; |
829 | 830 |
830 DCHECK(process_id == -1 || session_storage_namespace); | 831 DCHECK(process_id == -1 || session_storage_namespace); |
831 | 832 |
832 scoped_ptr<PrerenderHandle> swap_prerender_handle(AddPrerender( | 833 scoped_ptr<PrerenderHandle> swap_prerender_handle(AddPrerender( |
833 origin, process_id, url, referrer, size, session_storage_namespace)); | 834 origin, process_id, -1, url, referrer, size, session_storage_namespace)); |
mmenke
2012/09/12 16:31:45
Won't this break PrerenderMsg_StoppedPrerender? W
| |
834 if (swap_prerender_handle.get()) { | 835 if (swap_prerender_handle.get()) { |
835 // AddPrerender has returned a new prerender handle to us. We want to make | 836 // AddPrerender has returned a new prerender handle to us. We want to make |
836 // |existing_prerender_handle| active, so swap the underlying PrerenderData | 837 // |existing_prerender_handle| active, so swap the underlying PrerenderData |
837 // between the two handles, and delete our old handle (which will release | 838 // between the two handles, and delete our old handle (which will release |
838 // our entry in the pending_prerender_list_). | 839 // our entry in the pending_prerender_list_). |
839 existing_prerender_handle->SwapPrerenderDataWith( | 840 existing_prerender_handle->SwapPrerenderDataWith( |
840 swap_prerender_handle.get()); | 841 swap_prerender_handle.get()); |
841 swap_prerender_handle->OnCancel(); | 842 swap_prerender_handle->OnCancel(); |
842 return; | 843 return; |
843 } | 844 } |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
896 on_close_tab_contents_deleters_.clear(); | 897 on_close_tab_contents_deleters_.clear(); |
897 profile_ = NULL; | 898 profile_ = NULL; |
898 | 899 |
899 DCHECK(active_prerender_list_.empty()); | 900 DCHECK(active_prerender_list_.empty()); |
900 } | 901 } |
901 | 902 |
902 // private | 903 // private |
903 PrerenderHandle* PrerenderManager::AddPrerender( | 904 PrerenderHandle* PrerenderManager::AddPrerender( |
904 Origin origin, | 905 Origin origin, |
905 int process_id, | 906 int process_id, |
907 int prerender_id, | |
906 const GURL& url_arg, | 908 const GURL& url_arg, |
907 const content::Referrer& referrer, | 909 const content::Referrer& referrer, |
908 const gfx::Size& size, | 910 const gfx::Size& size, |
909 SessionStorageNamespace* session_storage_namespace) { | 911 SessionStorageNamespace* session_storage_namespace) { |
910 DCHECK(CalledOnValidThread()); | 912 DCHECK(CalledOnValidThread()); |
911 | 913 |
912 if (!IsEnabled()) | 914 if (!IsEnabled()) |
913 return NULL; | 915 return NULL; |
914 | 916 |
915 if (origin == ORIGIN_LINK_REL_PRERENDER && | 917 if (origin == ORIGIN_LINK_REL_PRERENDER && |
(...skipping 14 matching lines...) Expand all Loading... | |
930 url = alias_url; | 932 url = alias_url; |
931 } | 933 } |
932 | 934 |
933 // From here on, we will record a FinalStatus so we need to register with the | 935 // From here on, we will record a FinalStatus so we need to register with the |
934 // histogram tracking. | 936 // histogram tracking. |
935 histograms_->RecordPrerender(origin, url_arg); | 937 histograms_->RecordPrerender(origin, url_arg); |
936 | 938 |
937 if (PrerenderData* preexisting_prerender_data = | 939 if (PrerenderData* preexisting_prerender_data = |
938 FindPrerenderData(url, session_storage_namespace)) { | 940 FindPrerenderData(url, session_storage_namespace)) { |
939 RecordFinalStatus(origin, experiment, FINAL_STATUS_DUPLICATE); | 941 RecordFinalStatus(origin, experiment, FINAL_STATUS_DUPLICATE); |
940 return new PrerenderHandle(preexisting_prerender_data); | 942 return new PrerenderHandle(preexisting_prerender_data); |
mmenke
2012/09/12 16:31:45
When we merge prerenders, only one of them will ev
| |
941 } | 943 } |
942 | 944 |
943 // Do not prerender if there are too many render processes, and we would | 945 // Do not prerender if there are too many render processes, and we would |
944 // have to use an existing one. We do not want prerendering to happen in | 946 // have to use an existing one. We do not want prerendering to happen in |
945 // a shared process, so that we can always reliably lower the CPU | 947 // a shared process, so that we can always reliably lower the CPU |
946 // priority for prerendering. | 948 // priority for prerendering. |
947 // In single-process mode, ShouldTryToUseExistingProcessHost() always returns | 949 // In single-process mode, ShouldTryToUseExistingProcessHost() always returns |
948 // true, so that case needs to be explicitly checked for. | 950 // true, so that case needs to be explicitly checked for. |
949 // TODO(tburkard): Figure out how to cancel prerendering in the opposite | 951 // TODO(tburkard): Figure out how to cancel prerendering in the opposite |
950 // case, when a new tab is added to a process used for prerendering. | 952 // case, when a new tab is added to a process used for prerendering. |
(...skipping 29 matching lines...) Expand all Loading... | |
980 this, prerender_contents, GetExpiryTimeForNewPrerender()))); | 982 this, prerender_contents, GetExpiryTimeForNewPrerender()))); |
981 | 983 |
982 PrerenderHandle* prerender_handle = | 984 PrerenderHandle* prerender_handle = |
983 new PrerenderHandle(active_prerender_list_.back().get()); | 985 new PrerenderHandle(active_prerender_list_.back().get()); |
984 | 986 |
985 last_prerender_start_time_ = GetCurrentTimeTicks(); | 987 last_prerender_start_time_ = GetCurrentTimeTicks(); |
986 | 988 |
987 gfx::Size contents_size = | 989 gfx::Size contents_size = |
988 size.IsEmpty() ? config_.default_tab_bounds.size() : size; | 990 size.IsEmpty() ? config_.default_tab_bounds.size() : size; |
989 | 991 |
990 prerender_contents->StartPrerendering(process_id, contents_size, | 992 prerender_contents->StartPrerendering(process_id, prerender_id, contents_size, |
991 session_storage_namespace, | 993 session_storage_namespace, |
992 control_group_behavior); | 994 control_group_behavior); |
993 | 995 |
994 while (active_prerender_list_.size() > config_.max_concurrency) { | 996 while (active_prerender_list_.size() > config_.max_concurrency) { |
995 prerender_contents = active_prerender_list_.front()->contents_; | 997 prerender_contents = active_prerender_list_.front()->contents_; |
996 DCHECK(prerender_contents); | 998 DCHECK(prerender_contents); |
997 prerender_contents->Destroy(FINAL_STATUS_EVICTED); | 999 prerender_contents->Destroy(FINAL_STATUS_EVICTED); |
998 } | 1000 } |
999 | 1001 |
1000 histograms_->RecordConcurrency(active_prerender_list_.size(), | 1002 histograms_->RecordConcurrency(active_prerender_list_.size(), |
(...skipping 287 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1288 if (!render_process_host || !render_process_host->GetBrowserContext()) | 1290 if (!render_process_host || !render_process_host->GetBrowserContext()) |
1289 return NULL; | 1291 return NULL; |
1290 Profile* profile = Profile::FromBrowserContext( | 1292 Profile* profile = Profile::FromBrowserContext( |
1291 render_process_host->GetBrowserContext()); | 1293 render_process_host->GetBrowserContext()); |
1292 if (!profile) | 1294 if (!profile) |
1293 return NULL; | 1295 return NULL; |
1294 return PrerenderManagerFactory::GetInstance()->GetForProfile(profile); | 1296 return PrerenderManagerFactory::GetInstance()->GetForProfile(profile); |
1295 } | 1297 } |
1296 | 1298 |
1297 } // namespace prerender | 1299 } // namespace prerender |
OLD | NEW |