Upstreaming prerendering changes for Android.

chrome/browser/prerender/prerender_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/prerender/prerender_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 250 matching lines @@
 
 void PrerenderManager::Shutdown() {
   DoShutdown();
 }
 
 bool PrerenderManager::AddPrerenderFromLinkRelPrerender(
     int process_id,
     int route_id,
     const GURL& url,
     const content::Referrer& referrer) {
+#if defined(OS_ANDROID)
+  // TODO(jcivelli): http://crbug.com/113322 We should have an option to disable
+  //                link-prerender and enable omnibox-prerender only.
+  return false;
+#else
   std::pair<int, int> child_route_id_pair = std::make_pair(process_id,
                                                            route_id);
 
   return AddPrerender(ORIGIN_LINK_REL_PRERENDER, child_route_id_pair,
                       url, referrer, NULL);
+#endif
 }
 
 bool PrerenderManager::AddPrerenderFromOmnibox(
     const GURL& url,
     SessionStorageNamespace* session_storage_namespace) {
   if (!IsOmniboxEnabled(profile_))
     return false;
   return AddPrerender(ORIGIN_OMNIBOX, std::make_pair(-1, -1), url,
                       content::Referrer(), session_storage_namespace);
 }
@@ skipping 341 matching lines @@
     TabContentsWrapper* prerender_tab_contents_wrapper =
         (*it)->prerender_contents();
     if (prerender_tab_contents_wrapper &&
         prerender_tab_contents_wrapper->web_contents() == web_contents)
       return true;
   }
 
   return false;
 }
 
+bool PrerenderManager::DidPrerenderFinishLoading(const GURL& url) const {
+  DCHECK(CalledOnValidThread());
+  PrerenderContents* contents = FindEntry(url);
+  return contents ? contents->has_finished_loading() : false;
+}
+
 void PrerenderManager::MarkWebContentsAsPrerendered(WebContents* web_contents) {
   DCHECK(CalledOnValidThread());
   prerendered_tab_contents_set_.insert(web_contents);
 }
 
 void PrerenderManager::MarkWebContentsAsWouldBePrerendered(
     WebContents* web_contents) {
   DCHECK(CalledOnValidThread());
   would_be_prerendered_tab_contents_set_.insert(web_contents);
 }
@@ skipping 174 matching lines @@
   }
 
   // Do not prerender if there are too many render processes, and we would
   // have to use an existing one.  We do not want prerendering to happen in
   // a shared process, so that we can always reliably lower the CPU
   // priority for prerendering.
   // In single-process mode, ShouldTryToUseExistingProcessHost() always returns
   // true, so that case needs to be explicitly checked for.
   // TODO(tburkard): Figure out how to cancel prerendering in the opposite
   // case, when a new tab is added to a process used for prerendering.
+  // On Android we do reuse processes as we have a limited number of them and we
+  // still want the benefits of prerendering even when several tabs are open.
+#if !defined(OS_ANDROID)
   if (content::RenderProcessHost::ShouldTryToUseExistingProcessHost() &&
       !content::RenderProcessHost::run_renderer_in_process()) {
     RecordFinalStatus(origin, experiment, FINAL_STATUS_TOO_MANY_PROCESSES);
     return false;
   }
+#endif
 
   // Check if enough time has passed since the last prerender.
   if (!DoesRateLimitAllowPrerender()) {
     // Cancel the prerender. We could add it to the pending prerender list but
     // this doesn't make sense as the next prerender request will be triggered
     // by a navigation and is unlikely to be the same site.
     RecordFinalStatus(origin, experiment, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
     return false;
   }
 
@@ skipping 330 matching lines @@
   if (!render_process_host || !render_process_host->GetBrowserContext())
     return NULL;
   Profile* profile = Profile::FromBrowserContext(
       render_process_host->GetBrowserContext());
   if (!profile)
     return NULL;
   return PrerenderManagerFactory::GetInstance()->GetForProfile(profile);
 }
 
 }  // namespace prerender