Move pending prerender logic into PrerenderLinkManager.

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 <algorithm>
 #include <functional>
 #include <string>
 #include <vector>
@@ skipping 330 matching lines @@
     if (!source_web_contents)
       return NULL;
     if (source_web_contents->GetURL().host() == url.host())
       origin = ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN;
     // TODO(ajwong): This does not correctly handle storage for isolated apps.
     session_storage_namespace =
         source_web_contents->GetController()
             .GetDefaultSessionStorageNamespace();
   }
 
-  // If the prerender request comes from a recently cancelled prerender that
-  // |this| still owns, then abort the prerender.
-  for (ScopedVector<PrerenderData>::iterator it = to_delete_prerenders_.begin();
-       it != to_delete_prerenders_.end(); ++it) {
-    PrerenderContents* prerender_contents = (*it)->contents();
-    int contents_child_id;
-    int contents_route_id;
-    if (prerender_contents->GetChildId(&contents_child_id) &&
-        prerender_contents->GetRouteId(&contents_route_id)) {
-      if (contents_child_id == process_id && contents_route_id == route_id)
-        return NULL;
-    }
-  }
-
-  if (PrerenderData* parent_prerender_data =
-          FindPrerenderDataForChildAndRoute(process_id, route_id)) {
-    // Instead of prerendering from inside of a running prerender, we will defer
-    // this request until its launcher is made visible.
-    if (PrerenderContents* contents = parent_prerender_data->contents()) {
-      PrerenderHandle* prerender_handle =
-          new PrerenderHandle(static_cast<PrerenderData*>(NULL));
-      scoped_ptr<PrerenderContents::PendingPrerenderInfo>
-          pending_prerender_info(new PrerenderContents::PendingPrerenderInfo(
-              prerender_handle->weak_ptr_factory_.GetWeakPtr(),
-              origin, url, referrer, size));
-
-      contents->AddPendingPrerender(pending_prerender_info.Pass());
-      return prerender_handle;
-    }
-  }
-
   return AddPrerender(origin, process_id, url, referrer, size,
                       session_storage_namespace);
 }
 
 PrerenderHandle* PrerenderManager::AddPrerenderFromOmnibox(
     const GURL& url,
     SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
   if (!IsOmniboxEnabled(profile_))
     return NULL;
@@ skipping 200 matching lines @@
 
   // For bookkeeping purposes, we need to mark this WebContents to
   // reflect that it would have been prerendered.
   if (GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP) {
     MarkWebContentsAsWouldBePrerendered(web_contents,
                                         prerender_data->contents()->origin());
     prerender_data->contents()->Destroy(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
     return NULL;
   }
 
-  int child_id, route_id;
-  CHECK(prerender_data->contents()->GetChildId(&child_id));
-  CHECK(prerender_data->contents()->GetRouteId(&route_id));
-
   // At this point, we've determined that we will use the prerender.
   if (prerender_data->pending_swap())
     prerender_data->pending_swap()->set_swap_successful(true);
   ScopedVector<PrerenderData>::iterator to_erase =
       FindIteratorForPrerenderContents(prerender_data->contents());
   DCHECK(active_prerenders_.end() != to_erase);
   DCHECK_EQ(prerender_data, *to_erase);
   scoped_ptr<PrerenderContents>
       prerender_contents(prerender_data->ReleaseContents());
   active_prerenders_.erase(to_erase);
 
   if (!prerender_contents->load_start_time().is_null()) {
     histograms_->RecordTimeUntilUsed(
         prerender_contents->origin(),
         GetCurrentTimeTicks() - prerender_contents->load_start_time());
   }
 
   histograms_->RecordPerSessionCount(prerender_contents->origin(),
                                      ++prerenders_per_session_count_);
   histograms_->RecordUsedPrerender(prerender_contents->origin());
-  prerender_contents->SetFinalStatus(FINAL_STATUS_USED);
 
-  // Start pending prerender requests from the PrerenderContents, if there are
-  // any.
+  // Mark prerender as used.
   prerender_contents->PrepareForUse();
 
   WebContents* new_web_contents =
       prerender_contents->ReleasePrerenderContents();
   WebContents* old_web_contents = web_contents;
   DCHECK(new_web_contents);
   DCHECK(old_web_contents);
 
   MarkWebContentsAsPrerendered(new_web_contents, prerender_contents->origin());
 
@@ skipping 240 matching lines @@
        it != to_delete_prerenders_.end(); ++it) {
     WebContents* prerender_web_contents =
         (*it)->contents()->prerender_contents();
     if (prerender_web_contents == web_contents) {
       return (*it)->contents();
     }
   }
   return NULL;
 }
 
+PrerenderContents* PrerenderManager::GetPrerenderContentsForRoute(
+    int child_id,
+    int route_id) const {
+  content::WebContents* web_contents =
+      tab_util::GetWebContentsByID(child_id, route_id);
+  if (web_contents == NULL)
+    return NULL;
+  return GetPrerenderContents(web_contents);
+}
+
 const std::vector<WebContents*>
 PrerenderManager::GetAllPrerenderingContents() const {
   DCHECK(CalledOnValidThread());
   std::vector<WebContents*> result;
 
   for (ScopedVector<PrerenderData>::const_iterator it =
            active_prerenders_.begin();
        it != active_prerenders_.end(); ++it) {
     if (WebContents* contents = (*it)->contents()->prerender_contents())
       result.push_back(contents);
@@ skipping 403 matching lines @@
   RecordEvent(PRERENDER_EVENT_MERGE_RESULT_TIMED_OUT);
   prerender_data_->ClearPendingSwap();
 }
 
 void PrerenderManager::SetPrerenderContentsFactory(
     PrerenderContents::Factory* prerender_contents_factory) {
   DCHECK(CalledOnValidThread());
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
-
-void PrerenderManager::StartPendingPrerenders(
-    const int process_id,
-    ScopedVector<PrerenderContents::PendingPrerenderInfo>* pending_prerenders,
-    content::SessionStorageNamespace* session_storage_namespace) {
-  for (ScopedVector<PrerenderContents::PendingPrerenderInfo>::iterator
-           it = pending_prerenders->begin();
-       it != pending_prerenders->end(); ++it) {
-    PrerenderContents::PendingPrerenderInfo* info = *it;
-    PrerenderHandle* existing_prerender_handle =
-        info->weak_prerender_handle.get();
-    if (!existing_prerender_handle)
-      continue;
-
-    DCHECK(!existing_prerender_handle->IsPrerendering());
-    DCHECK(process_id == -1 || session_storage_namespace);
-
-    scoped_ptr<PrerenderHandle> new_prerender_handle(AddPrerender(
-        info->origin, process_id,
-        info->url, info->referrer, info->size,
-        session_storage_namespace));
-    if (new_prerender_handle) {
-      // AddPrerender has returned a new prerender handle to us. We want to make
-      // |existing_prerender_handle| active, so move the underlying
-      // PrerenderData to our new handle.
-      existing_prerender_handle->AdoptPrerenderDataFrom(
-          new_prerender_handle.get());
-      continue;
-    }
-  }
-}
-
 void PrerenderManager::SourceNavigatedAway(PrerenderData* prerender_data) {
   // The expiry time of our prerender data will likely change because of
   // this navigation. This requires a resort of active_prerenders_.
   ScopedVector<PrerenderData>::iterator it =
       std::find(active_prerenders_.begin(), active_prerenders_.end(),
                 prerender_data);
   if (it == active_prerenders_.end())
     return;
 
   (*it)->set_expiry_time(
@@ skipping 232 matching lines @@
     const SessionStorageNamespace* session_storage_namespace) {
   for (ScopedVector<PrerenderData>::iterator it = active_prerenders_.begin();
        it != active_prerenders_.end(); ++it) {
     if ((*it)->contents()->Matches(url, session_storage_namespace))
       return *it;
   }
   return NULL;
 }
 
 PrerenderManager::PrerenderData*
-PrerenderManager::FindPrerenderDataForChildAndRoute(
-    const int child_id, const int route_id) {
-  for (ScopedVector<PrerenderData>::iterator it = active_prerenders_.begin();
-       it != active_prerenders_.end(); ++it) {
-    PrerenderContents* prerender_contents = (*it)->contents();
-
-    int contents_child_id;
-    if (!prerender_contents->GetChildId(&contents_child_id))
-      continue;
-    int contents_route_id;
-    if (!prerender_contents->GetRouteId(&contents_route_id))
-      continue;
-
-    if (contents_child_id == child_id && contents_route_id == route_id)
-      return *it;
-  }
-  return NULL;
-}
-
-PrerenderManager::PrerenderData*
 PrerenderManager::FindPrerenderDataForTargetContents(
     WebContents* target_contents) {
   for (ScopedVector<PrerenderData>::iterator it = active_prerenders_.begin();
        it != active_prerenders_.end(); ++it) {
     if ((*it)->pending_swap() &&
         (*it)->pending_swap()->target_contents() == target_contents)
       return *it;
   }
   return NULL;
 }
@@ skipping 330 matching lines @@
     history::VisitVector* visists) {
   histograms_->RecordPrerenderPageVisitedStatus(origin, experiment_id, success);
 }
 
 // static
 void PrerenderManager::HangSessionStorageMergesForTesting() {
   g_hang_session_storage_merges_for_testing = true;
 }
 
 }  // namespace prerender