Add to the prerender history when no PrerenderContents is created.

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 1254 matching lines @@
       MaybeGetQueryStringBasedAliasURL(url, &alias_url)) {
     url = alias_url;
   }
 
   // From here on, we will record a FinalStatus so we need to register with the
   // histogram tracking.
   histograms_->RecordPrerender(origin, url_arg);
 
   if (PrerenderData* preexisting_prerender_data =
           FindPrerenderData(url, session_storage_namespace)) {
-    RecordFinalStatus(origin, experiment, FINAL_STATUS_DUPLICATE);
+    RecordFinalStatusWithoutCreatingPrerenderContents(
+        url, origin, experiment, FINAL_STATUS_DUPLICATE);
     return new PrerenderHandle(preexisting_prerender_data);
   }
 
   // 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.
   // TODO(ppi): Check whether there are usually enough render processes
   // available on Android. If not, kill an existing renderers so that we can
   // create a new one.
   if (content::RenderProcessHost::ShouldTryToUseExistingProcessHost(
           profile_, url) &&
       !content::RenderProcessHost::run_renderer_in_process()) {
-    RecordFinalStatus(origin, experiment, FINAL_STATUS_TOO_MANY_PROCESSES);
+    RecordFinalStatusWithoutCreatingPrerenderContents(
+        url, origin, experiment, FINAL_STATUS_TOO_MANY_PROCESSES);
     return NULL;
   }
 
   // Check if enough time has passed since the last prerender.
   if (!DoesRateLimitAllowPrerender(origin)) {
     // 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);
+    RecordFinalStatusWithoutCreatingPrerenderContents(
+        url, origin, experiment, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
     return NULL;
   }
 
   if (!cookie_store_loaded()) {
     // Only prerender if the cookie store for this profile has been loaded.
     // This is required by PrerenderCookieMonster.
     RecordFinalStatus(origin, experiment, FINAL_STATUS_COOKIE_STORE_NOT_LOADED);
     return NULL;
   }
 
@@ skipping 278 matching lines @@
     FinalStatus final_status) {
   prerender_contents->set_match_complete_status(
       PrerenderContents::MATCH_COMPLETE_REPLACED);
   histograms_->RecordFinalStatus(prerender_contents->origin(),
                                  prerender_contents->experiment_id(),
                                  PrerenderContents::MATCH_COMPLETE_REPLACEMENT,
                                  FINAL_STATUS_WOULD_HAVE_BEEN_USED);
   prerender_contents->Destroy(final_status);
 }
 
-void PrerenderManager::RecordFinalStatus(Origin origin,
-                                         uint8 experiment_id,
-                                         FinalStatus final_status) const {
+void PrerenderManager::RecordFinalStatusWithoutCreatingPrerenderContents(
+    const GURL& url, Origin origin, uint8 experiment_id,
+    FinalStatus final_status) const {
+  PrerenderHistory::Entry entry(url, final_status, origin, base::Time::Now());
+  prerender_history_->AddEntry(entry);
   RecordFinalStatusWithMatchCompleteStatus(
       origin, experiment_id,
       PrerenderContents::MATCH_COMPLETE_DEFAULT,
       final_status);
 }
 
 bool PrerenderManager::IsEnabled() const {
   DCHECK(CalledOnValidThread());
   if (!enabled_)
     return false;
@@ skipping 273 matching lines @@
     content::RenderProcessHost* host) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prerender_process_hosts_.erase(host);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PrerenderTracker::RemovePrerenderCookieStoreOnIOThread,
                  base::Unretained(prerender_tracker()), host->GetID(), false));
 }
 
 }  // namespace prerender