PrerenderManager public API cleanup.

BUG=
TEST=Prerender*


Review URL: http://codereview.chromium.org/7272011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@90815 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 168 insertions, 170 deletions

diff --git a/chrome/browser/autocomplete/autocomplete_edit.cc b/chrome/browser/autocomplete/autocomplete_edit.cc
index 8c6eb8f..048bea2 100644
--- a/chrome/browser/autocomplete/autocomplete_edit.cc
+++ b/chrome/browser/autocomplete/autocomplete_edit.cc
@@ -237,8 +237,8 @@ void AutocompleteEditModel::OnChanged() {
       prerender::PrerenderManager* prerender_manager =
           tab->tab_contents()->profile()->GetPrerenderManager();
       if (prerender_manager) {
-        prerender_manager->AddPrerender(prerender::ORIGIN_OMNIBOX,
-                                        CurrentMatch().destination_url);
+        prerender_manager->AddPrerenderFromOmnibox(
+            CurrentMatch().destination_url);
       }
     }
   }
diff --git a/chrome/browser/instant/instant_controller.cc b/chrome/browser/instant/instant_controller.cc
index 7269522..61cedf0 100644
--- a/chrome/browser/instant/instant_controller.cc
+++ b/chrome/browser/instant/instant_controller.cc
@@ -176,10 +176,8 @@ void InstantController::Update(TabContentsWrapper* tab_contents,
     // Start Prerender of this page instead.
     prerender::PrerenderManager* prerender_manager =
         tab_contents_->profile()->GetPrerenderManager();
-    if (prerender_manager) {
-      prerender_manager->AddPrerender(prerender::ORIGIN_OMNIBOX,
-                                      match.destination_url);
-    }
+    if (prerender_manager)
+      prerender_manager->AddPrerenderFromOmnibox(match.destination_url);
 
     DestroyPreviewContentsAndLeaveActive();
     return;
diff --git a/chrome/browser/prerender/prerender_manager.cc b/chrome/browser/prerender/prerender_manager.cc
index 67b37a8..4ddc3da 100644
--- a/chrome/browser/prerender/prerender_manager.cc
+++ b/chrome/browser/prerender/prerender_manager.cc
@@ -217,39 +217,6 @@ struct PrerenderManager::PendingContentsData {
   Origin origin_;
 };
 
-void HandleTag(
-    const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
-    int render_process_id,
-    int render_view_id,
-    const GURL& url,
-    const GURL& referrer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  PrerenderManager* prerender_manager = prerender_manager_weak_ptr.get();
-  if (!prerender_manager || !prerender_manager->is_enabled())
-    return;
-  prerender_manager->RecordTagObserved();
-
-  std::pair<int, int> child_route_id_pair = std::make_pair(render_process_id,
-                                                           render_view_id);
-
-  prerender_manager->AddPrerenderFromPage(ORIGIN_LINK_REL_PRERENDER,
-                                          child_route_id_pair, url, referrer);
-}
-
-void DestroyPrerenderForRenderView(
-    const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
-    int render_process_id,
-    int render_view_id,
-    FinalStatus final_status) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  PrerenderManager* prerender_manager = prerender_manager_weak_ptr.get();
-  if (!prerender_manager)
-    return;
-
-  prerender_manager->DestroyPrerenderForChildRouteIdPair(
-      std::make_pair(render_process_id, render_view_id),
-      final_status);
-}
 
 PrerenderManager::PrerenderManager(Profile* profile,
                                    PrerenderTracker* prerender_tracker)
@@ -282,13 +249,37 @@ void PrerenderManager::SetPrerenderContentsFactory(
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
-bool PrerenderManager::AddPrerenderFromPage(
+bool PrerenderManager::AddPrerenderFromLinkRelPrerender(int process_id,
+                                                        int route_id,
+                                                        const GURL& url,
+                                                        const GURL& referrer) {
+  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);
+}
+
+bool PrerenderManager::AddPrerenderFromOmnibox(const GURL& url) {
+  CommandLine* cl = CommandLine::ForCurrentProcess();
+  if (!cl->HasSwitch(switches::kPrerenderFromOmnibox))
+    return false;
+
+  return AddPrerender(ORIGIN_OMNIBOX, std::make_pair(-1, -1), url, GURL());
+}
+
+bool PrerenderManager::AddPrerender(
     Origin origin,
     const std::pair<int, int>& child_route_id_pair,
     const GURL& url_arg,
     const GURL& referrer) {
   DCHECK(CalledOnValidThread());
 
+  // If we observe multiple tags within the 30 second window, we will still
+  // reset the window to begin at the most recent occurrence, so that we will
+  // always be in a window in the 30 seconds from each occurrence.
+  last_prerender_seen_time_ = GetCurrentTimeTicks();
+
   // If the referring page is prerendering, defer the prerender.
   if (FindPrerenderContentsForChildRouteIdPair(child_route_id_pair) !=
           prerender_list_.end()) {
@@ -372,19 +363,6 @@ bool PrerenderManager::AddPrerenderFromPage(
   return true;
 }
 
-bool PrerenderManager::AddPrerender(Origin origin, const GURL& url) {
-  bool should_prerender = true;
-  if (origin == ORIGIN_OMNIBOX) {
-    CommandLine* cl = CommandLine::ForCurrentProcess();
-    should_prerender = cl->HasSwitch(switches::kPrerenderFromOmnibox);
-  }
-
-  if (!should_prerender)
-    return false;
-
-  return AddPrerenderFromPage(origin, std::make_pair(-1, -1), url, GURL());
-}
-
 void PrerenderManager::AddPendingPrerender(
     Origin origin,
     const std::pair<int, int>& child_route_id_pair,
@@ -425,12 +403,12 @@ std::list<PrerenderManager::PrerenderContentsData>::iterator
   return it;
 }
 
-void PrerenderManager::DestroyPrerenderForChildRouteIdPair(
-    const std::pair<int, int>& child_route_id_pair,
-    FinalStatus final_status) {
+void PrerenderManager::DestroyPrerenderForRenderView(
+    int process_id, int view_id, FinalStatus final_status) {
   DCHECK(CalledOnValidThread());
   std::list<PrerenderContentsData>::iterator it =
-      FindPrerenderContentsForChildRouteIdPair(child_route_id_pair);
+      FindPrerenderContentsForChildRouteIdPair(
+          std::make_pair(process_id, view_id));
   if (it != prerender_list_.end()) {
     PrerenderContents* prerender_contents = it->contents_;
     prerender_contents->Destroy(final_status);
@@ -479,6 +457,8 @@ bool PrerenderManager::MaybeUsePrerenderedPage(TabContents* tab_contents,
                                                const GURL& url,
                                                bool has_opener_set) {
   DCHECK(CalledOnValidThread());
+  RecordNavigation(url);
+
   scoped_ptr<PrerenderContents> prerender_contents(
       GetEntryButNotSpecifiedTC(url, tab_contents));
   if (prerender_contents.get() == NULL)
@@ -582,8 +562,8 @@ bool PrerenderManager::MaybeUsePrerenderedPage(TabContents* tab_contents,
     for (std::vector<PendingContentsData>::iterator content_it =
             pending_it->second.begin();
          content_it != pending_it->second.end(); ++content_it) {
-      AddPrerenderFromPage(content_it->origin_, pending_it->first,
-                           content_it->url_, content_it->referrer_);
+      AddPrerender(content_it->origin_, child_route_pair,
+                   content_it->url_, content_it->referrer_);
     }
     pending_prerender_list_.erase(pending_it);
   }
@@ -623,19 +603,6 @@ void PrerenderManager::MoveEntryToPendingDelete(PrerenderContents* entry) {
   PostCleanupTask();
 }
 
-bool PrerenderManager::IsPendingDelete(PrerenderContents* entry) const {
-  DCHECK(CalledOnValidThread());
-  for (std::list<PrerenderContents*>::const_iterator it =
-          pending_delete_list_.begin();
-       it != pending_delete_list_.end();
-       ++it) {
-    if (*it == entry)
-      return true;
-  }
-
-  return false;
-}
-
 base::Time PrerenderManager::GetCurrentTime() const {
   return base::Time::Now();
 }
@@ -659,6 +626,19 @@ PrerenderContents* PrerenderManager::CreatePrerenderContents(
       this, prerender_tracker_, profile_, url, referrer, origin);
 }
 
+bool PrerenderManager::IsPendingDelete(PrerenderContents* entry) const {
+  DCHECK(CalledOnValidThread());
+  for (std::list<PrerenderContents*>::const_iterator it =
+          pending_delete_list_.begin();
+       it != pending_delete_list_.end();
+       ++it) {
+    if (*it == entry)
+      return true;
+  }
+
+  return false;
+}
+
 void PrerenderManager::DeletePendingDeleteEntries() {
   while (!pending_delete_list_.empty()) {
     PrerenderContents* contents = pending_delete_list_.front();
@@ -706,16 +686,6 @@ void PrerenderManager::RecordPerceivedPageLoadTime(
   }
 }
 
-void PrerenderManager::RecordTimeUntilUsed(base::TimeDelta time_until_used) {
-  DCHECK(CalledOnValidThread());
-  UMA_HISTOGRAM_CUSTOM_TIMES(
-      "Prerender.TimeUntilUsed",
-      time_until_used,
-      base::TimeDelta::FromMilliseconds(10),
-      base::TimeDelta::FromSeconds(kDefaultMaxPrerenderAgeSeconds),
-      50);
-}
-
 base::TimeDelta PrerenderManager::max_prerender_age() const {
   DCHECK(CalledOnValidThread());
   return max_prerender_age_;
@@ -787,15 +757,6 @@ PrerenderManager::PendingContentsData*
   return NULL;
 }
 
-void PrerenderManager::RecordTagObserved() {
-  DCHECK(CalledOnValidThread());
-
-  // If we observe multiple tags within the 30 second window, we will still
-  // reset the window to begin at the most recent occurrence, so that we will
-  // always be in a window in the 30 seconds from each occurrence.
-  last_prerender_seen_time_ = base::TimeTicks::Now();
-}
-
 void PrerenderManager::RemovePendingPrerender(PrerenderContents* entry) {
   DCHECK(CalledOnValidThread());
   int child_id;
@@ -962,13 +923,6 @@ bool PrerenderManager::WouldTabContentsBePrerendered(
   return would_be_prerendered_tab_contents_set_.count(tab_contents) > 0;
 }
 
-void PrerenderManager::RecordNavigation(const GURL& url) {
-  DCHECK(CalledOnValidThread());
-
-  navigations_.push_back(NavigationRecord(url, GetCurrentTimeTicks()));
-  CleanUpOldNavigations();
-}
-
 bool PrerenderManager::HasRecentlyBeenNavigatedTo(const GURL& url) {
   DCHECK(CalledOnValidThread());
 
@@ -1031,6 +985,21 @@ void PrerenderManager::ClearData(int clear_flags) {
     prerender_history_->Clear();
 }
 
+void PrerenderManager::AddToHistory(PrerenderContents* contents) {
+  PrerenderHistory::Entry entry(contents->prerender_url(),
+                                contents->final_status(),
+                                contents->origin(),
+                                base::Time::Now());
+  prerender_history_->AddEntry(entry);
+}
+
+void PrerenderManager::RecordNavigation(const GURL& url) {
+  DCHECK(CalledOnValidThread());
+
+  navigations_.push_back(NavigationRecord(url, GetCurrentTimeTicks()));
+  CleanUpOldNavigations();
+}
+
 Value* PrerenderManager::GetActivePrerendersAsValue() const {
   ListValue* list_value = new ListValue();
   for (std::list<PrerenderContentsData>::const_iterator it =
@@ -1045,14 +1014,6 @@ Value* PrerenderManager::GetActivePrerendersAsValue() const {
   return list_value;
 }
 
-void PrerenderManager::AddToHistory(PrerenderContents* contents) {
-  PrerenderHistory::Entry entry(contents->prerender_url(),
-                                contents->final_status(),
-                                contents->origin(),
-                                base::Time::Now());
-  prerender_history_->AddEntry(entry);
-}
-
 void PrerenderManager::DestroyAllContents(FinalStatus final_status) {
   DeleteOldTabContents();
   while (!prerender_list_.empty()) {
@@ -1063,4 +1024,14 @@ void PrerenderManager::DestroyAllContents(FinalStatus final_status) {
   DeletePendingDeleteEntries();
 }
 
+void PrerenderManager::RecordTimeUntilUsed(base::TimeDelta time_until_used) {
+  DCHECK(CalledOnValidThread());
+  UMA_HISTOGRAM_CUSTOM_TIMES(
+      "Prerender.TimeUntilUsed",
+      time_until_used,
+      base::TimeDelta::FromMilliseconds(10),
+      base::TimeDelta::FromSeconds(kDefaultMaxPrerenderAgeSeconds),
+      50);
+}
+
 }  // namespace prerender
diff --git a/chrome/browser/prerender/prerender_manager.h b/chrome/browser/prerender/prerender_manager.h
index a5cf15c..189d9cb 100644
--- a/chrome/browser/prerender/prerender_manager.h
+++ b/chrome/browser/prerender/prerender_manager.h
@@ -43,21 +43,6 @@ namespace prerender {
 class PrerenderHistory;
 class PrerenderTracker;
 
-// Adds either a preload or a pending preload to the PrerenderManager.
-// Must be called on the UI thread.
-void HandleTag(
-    const base::WeakPtr<PrerenderManager>& prerender_manager,
-    int render_process_id,
-    int render_view_id,
-    const GURL& url,
-    const GURL& referrer);
-
-void DestroyPrerenderForRenderView(
-    const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
-    int child_id,
-    int route_id,
-    FinalStatus final_status);
-
 // PrerenderManager is responsible for initiating and keeping prerendered
 // views of webpages. All methods must be called on the UI thread unless
 // indicated otherwise.
@@ -87,30 +72,27 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
 
   virtual ~PrerenderManager();
 
-  // Starts a prerender for |url| if valid. |child_route_id_pair| identifies the
-  // RenderViewHost that the prerender request came from and is used to
+  // Entry points for adding prerenders.
+
+  // Adds a prerender for |url| if valid. |process_id| and |route_id| identify
+  // the RenderViewHost that the prerender request came from and are used to
   // set the initial window size of the RenderViewHost used for prerendering.
   // Returns true if the URL was added, false if it was not.
-  // If |child_route_id_pair| itself is prerendering, adds the preloads as
-  // a pending preload. |origin| enumerates the source of the prerender for
-  // data-tracking purposes.
-  bool AddPrerenderFromPage(
-      Origin origin,
-      const std::pair<int, int>& child_route_id_pair,
-      const GURL& url,
-      const GURL& referrer);
+  // If the RenderViewHost source is itself prerendering, the prerender is added
+  // as a pending prerender.
+  bool AddPrerenderFromLinkRelPrerender(int process_id, int route_id,
+                                        const GURL& url, const GURL& referrer);
 
-  // Starts a prerender for |url| if valid. As the prerender request is coming
+  // Adds a prerender for |url| if valid. As the prerender request is coming
   // from a source without a RenderViewHost (ie, the omnibox) we don't have a
   // child or route id, or a referrer. This method uses sensible values for
   // those.
-  bool AddPrerender(Origin origin, const GURL& url);
+  bool AddPrerenderFromOmnibox(const GURL& url);
 
   // Destroy all prerenders for the given child route id pair and assign a final
   // status to them.
-  virtual void DestroyPrerenderForChildRouteIdPair(
-      const std::pair<int, int>& child_route_id_pair,
-      FinalStatus final_status);
+  virtual void DestroyPrerenderForRenderView(int process_id, int view_id,
+                                             FinalStatus final_status);
 
   // For a given TabContents that wants to navigate to the URL supplied,
   // determines whether a prerendered version of the URL can be used,
@@ -124,9 +106,6 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   // active prerenders when prerendering should be cancelled.
   void MoveEntryToPendingDelete(PrerenderContents* entry);
 
-  // Checks if the PrerenderContents has been added to the pending delete list.
-  bool IsPendingDelete(PrerenderContents* entry) const;
-
   // Retrieves the PrerenderContents object for the specified URL, if it
   // has been prerendered.  The caller will then have ownership of the
   // PrerenderContents object and is responsible for freeing it.
@@ -148,15 +127,9 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
       base::TimeDelta perceived_page_load_time,
       TabContents* tab_contents);
 
-  // Records the time from when a page starts prerendering to when the user
-  // navigates to it. This must be called on the UI thread.
-  void RecordTimeUntilUsed(base::TimeDelta time_until_used);
-
-  base::TimeDelta max_prerender_age() const;
   void set_max_prerender_age(base::TimeDelta max_age);
   size_t max_prerender_memory_mb() const;
   void set_max_prerender_memory_mb(size_t prerender_memory_mb);
-  unsigned int max_elements() const;
   void set_max_elements(unsigned int num);
 
   // Returns whether prerendering is currently enabled for this manager.
@@ -174,9 +147,6 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   static bool IsPrerenderingPossible();
   static bool IsControlGroup();
 
-  // Records that a prerender tag has been observed.
-  void RecordTagObserved();
-
   // Query the list of current prerender pages to see if the given tab contents
   // is prerendering a page.
   bool IsTabContentsPrerendering(TabContents* tab_contents) const;
@@ -190,20 +160,10 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   bool WouldTabContentsBePrerendered(TabContents* tab_contents) const;
   bool IsOldRenderViewHost(const RenderViewHost* render_view_host) const;
 
-  // Records that some visible tab navigated (or was redirected) to the
-  // provided URL.
-  void RecordNavigation(const GURL& url);
-
   // Checks whether navigation to the provided URL has occured in a visible
   // tab recently.
   bool HasRecentlyBeenNavigatedTo(const GURL& url);
 
-  // Extracts a urlencoded URL stored in a url= query parameter from a URL
-  // supplied, if available, and stores it in alias_url.  Returns whether or not
-  // the operation succeeded (i.e. a valid URL was found).
-  static bool MaybeGetQueryStringBasedAliasURL(const GURL& url,
-                                               GURL* alias_url);
-
   // Returns true if the method given is invalid for prerendering.
   static bool IsValidHttpMethod(const std::string& method);
 
@@ -226,6 +186,10 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   void ClearData(int clear_flags);
 
  protected:
+  // Test that needs needs access to internal functions.
+  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, ExpireTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, ExtractURLInQueryStringTest);
+
   struct PendingContentsData;
 
   void SetPrerenderContentsFactory(
@@ -235,6 +199,15 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
 
   PendingContentsData* FindPendingEntry(const GURL& url);
 
+  // Extracts a urlencoded URL stored in a url= query parameter from a URL
+  // supplied, if available, and stores it in alias_url.  Returns whether or not
+  // the operation succeeded (i.e. a valid URL was found).
+  static bool MaybeGetQueryStringBasedAliasURL(const GURL& url,
+                                               GURL* alias_url);
+
+  base::TimeDelta max_prerender_age() const;
+  unsigned int max_elements() const;
+
  private:
   // Test that needs needs access to internal functions.
   friend class PrerenderBrowserTest;
@@ -246,6 +219,15 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
 
   class OnCloseTabContentsDeleter;
 
+  // Adds a prerender for |url| from referrer |referrer| initiated from the
+  // RenderViewHost specified by |child_route_id_pair|. The |origin| specifies
+  // how the prerender was added.
+  bool AddPrerender(
+      Origin origin,
+      const std::pair<int, int>& child_route_id_pair,
+      const GURL& url,
+      const GURL& referrer);
+
   // Adds a pending preload issued by the prerendering RenderView identified by
   // |child_route_id_pair|.  If and when that prerendering RenderView is used,
   // the specified prerender will start.
@@ -278,6 +260,9 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
                                                      const GURL& referrer,
                                                      Origin origin);
 
+  // Checks if the PrerenderContents has been added to the pending delete list.
+  bool IsPendingDelete(PrerenderContents* entry) const;
+
   // Deletes any PrerenderContents that have been added to the pending delete
   // list.
   void DeletePendingDeleteEntries();
@@ -320,6 +305,10 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   // Adds to the history list.
   void AddToHistory(PrerenderContents* contents);
 
+  // Records that some visible tab navigated (or was redirected) to the
+  // provided URL.
+  void RecordNavigation(const GURL& url);
+
   // Returns a new Value representing the pages currently being prerendered. The
   // caller is responsible for delete'ing the return value.
   Value* GetActivePrerendersAsValue() const;
@@ -329,6 +318,10 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   // Used both on destruction, and when clearing the browing history.
   void DestroyAllContents(FinalStatus final_status);
 
+  // Records the time from when a page starts prerendering to when the user
+  // navigates to it. This must be called on the UI thread.
+  void RecordTimeUntilUsed(base::TimeDelta time_until_used);
+
   // Specifies whether prerendering is currently enabled for this
   // manager. The value can change dynamically during the lifetime
   // of the PrerenderManager.
diff --git a/chrome/browser/prerender/prerender_manager_unittest.cc b/chrome/browser/prerender/prerender_manager_unittest.cc
index dd96725..e275eb5 100644
--- a/chrome/browser/prerender/prerender_manager_unittest.cc
+++ b/chrome/browser/prerender/prerender_manager_unittest.cc
@@ -121,7 +121,9 @@ class TestPrerenderManager : public PrerenderManager {
 
   // Shorthand to add a simple preload with a reasonable source.
   bool AddSimplePrerender(const GURL& url) {
-    return AddPrerender(ORIGIN_LINK_REL_PRERENDER, url);
+    return AddPrerenderFromLinkRelPrerender(-1, -1,
+                                            url,
+                                            GURL());
   }
 
   bool IsPendingEntry(const GURL& url) {
@@ -423,8 +425,8 @@ TEST_F(PrerenderManagerTest, PendingPrerenderTest) {
 
   GURL pending_url("http://news.google.com/");
 
-  EXPECT_TRUE(prerender_manager()->AddPrerenderFromPage(
-      ORIGIN_LINK_REL_PRERENDER, std::make_pair(child_id, route_id),
+  EXPECT_TRUE(prerender_manager()->AddPrerenderFromLinkRelPrerender(
+      child_id, route_id,
       pending_url, url));
 
   EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url));
@@ -473,8 +475,8 @@ TEST_F(PrerenderManagerTest, SourceRenderViewClosed) {
   prerender_manager()->CreateNextPrerenderContents(
       url,
       FINAL_STATUS_MANAGER_SHUTDOWN);
-  EXPECT_FALSE(prerender_manager()->AddPrerenderFromPage(
-      ORIGIN_LINK_REL_PRERENDER, std::pair<int, int>(100, 100), url, GURL()));
+  EXPECT_FALSE(prerender_manager()->AddPrerenderFromLinkRelPrerender(
+      100, 100, url, GURL()));
 }
 
 // Tests that the prerender manager ignores fragment references when matching
diff --git a/chrome/browser/prerender/prerender_observer.cc b/chrome/browser/prerender/prerender_observer.cc
index b75d945..5bcd38b 100644
--- a/chrome/browser/prerender/prerender_observer.cc
+++ b/chrome/browser/prerender/prerender_observer.cc
@@ -33,7 +33,6 @@ void PrerenderObserver::ProvisionalChangeToMainFrameUrl(const GURL& url,
     return;
   prerender_manager->MarkTabContentsAsNotPrerendered(tab_contents());
   MaybeUsePrerenderedPage(url, has_opener_set);
-  prerender_manager->RecordNavigation(url);
 }
 
 bool PrerenderObserver::OnMessageReceived(const IPC::Message& message) {
diff --git a/chrome/browser/prerender/prerender_tracker.cc b/chrome/browser/prerender/prerender_tracker.cc
index 719dae4..1500022 100644
--- a/chrome/browser/prerender/prerender_tracker.cc
+++ b/chrome/browser/prerender/prerender_tracker.cc
@@ -74,6 +74,21 @@ void HandleDelayedRequestOnUIThread(
   }
 }
 
+void DestroyPrerenderForRenderViewOnUI(
+    const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
+    int render_process_id,
+    int render_view_id,
+    FinalStatus final_status) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  PrerenderManager* prerender_manager = prerender_manager_weak_ptr.get();
+  if (!prerender_manager)
+    return;
+
+  prerender_manager->DestroyPrerenderForRenderView(
+      render_process_id, render_view_id, final_status);
+}
+
+
 void AddURL(const GURL& url, URLCounter* counter) {
   DCHECK(counter);
   counter->AddURL(url);
@@ -287,7 +302,7 @@ bool PrerenderTracker::SetFinalStatus(int child_id, int route_id,
     if (desired_final_status != FINAL_STATUS_USED) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
-          NewRunnableFunction(&DestroyPrerenderForRenderView,
+          NewRunnableFunction(&DestroyPrerenderForRenderViewOnUI,
                               final_status_it->second.prerender_manager,
                               child_id,
                               route_id,
diff --git a/chrome/browser/prerender/prerender_tracker_unittest.cc b/chrome/browser/prerender/prerender_tracker_unittest.cc
index c1cd80b..a9cef60 100644
--- a/chrome/browser/prerender/prerender_tracker_unittest.cc
+++ b/chrome/browser/prerender/prerender_tracker_unittest.cc
@@ -22,10 +22,9 @@ class TestPrerenderManager : public PrerenderManager {
     rate_limit_enabled_ = false;
   }
 
-  virtual void DestroyPrerenderForChildRouteIdPair(
-      const std::pair<int, int>& child_route_id_pair,
-      FinalStatus final_status) OVERRIDE {
-    cancelled_id_pairs_.insert(child_route_id_pair);
+  virtual void DestroyPrerenderForRenderView(
+      int process_id, int view_id, FinalStatus final_status) OVERRIDE {
+    cancelled_id_pairs_.insert(std::make_pair(process_id, view_id));
   }
 
   bool WasPrerenderCancelled(int child_id, int route_id) {
diff --git a/chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.cc b/chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.cc
index 5bc48c2..73fde30 100644
--- a/chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.cc
+++ b/chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.cc
@@ -30,6 +30,27 @@
 #include "chrome/browser/renderer_host/offline_resource_handler.h"
 #endif
 
+namespace {
+
+void AddPrerenderOnUI(
+    const base::WeakPtr<prerender::PrerenderManager>&
+        prerender_manager_weak_ptr,
+    int render_process_id, int render_view_id,
+    const GURL& url, const GURL& referrer) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  prerender::PrerenderManager* prerender_manager =
+      prerender_manager_weak_ptr.get();
+  if (!prerender_manager || !prerender_manager->is_enabled())
+    return;
+
+  prerender_manager->AddPrerenderFromLinkRelPrerender(render_process_id,
+                                                      render_view_id,
+                                                      url,
+                                                      referrer);
+}
+
+}  // end namespace
+
 ChromeResourceDispatcherHostDelegate::ChromeResourceDispatcherHostDelegate(
     ResourceDispatcherHost* resource_dispatcher_host,
     prerender::PrerenderTracker* prerender_tracker)
@@ -65,7 +86,7 @@ bool ChromeResourceDispatcherHostDelegate::ShouldBeginRequest(
   if (request_data.resource_type == ResourceType::PRERENDER) {
     if (prerender::PrerenderManager::IsPrerenderingPossible()) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-          NewRunnableFunction(prerender::HandleTag,
+          NewRunnableFunction(AddPrerenderOnUI,
                               resource_context.prerender_manager(),
                               child_id,
                               route_id,