Fix prerender histograms for multiple prerender case.

Unfortunately, the prerender histograms mechanism for determining origin was basically a global variable; when multiple prerenders can be in flight at the same time, this doesn't work so well.

To fix this, track the origin of prerenders in the PrerenderData and in the structure keeping track of prerendered web_contents, and pass explicit origins in for histogram recording.

The "wash" determination still uses the window, which is the same as the TTL, and so it's passed in at initialization rather than being another constant in prerender_histograms.cc.


BUG=None


Review URL: https://chromiumcodereview.appspot.com/11028037

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

15 files changed, 377 insertions, 180 deletions

diff --git a/chrome/browser/chrome_content_browser_client.cc b/chrome/browser/chrome_content_browser_client.cc
index bc454bc..e88c2ad 100644
--- a/chrome/browser/chrome_content_browser_client.cc
+++ b/chrome/browser/chrome_content_browser_client.cc
@@ -1197,7 +1197,8 @@ void ChromeContentBrowserClient::AllowCertificateError(
   prerender::PrerenderManager* prerender_manager =
       prerender::PrerenderManagerFactory::GetForProfile(
           Profile::FromBrowserContext(tab->GetBrowserContext()));
-  if (prerender_manager && prerender_manager->IsWebContentsPrerendering(tab)) {
+  if (prerender_manager && prerender_manager->IsWebContentsPrerendering(tab,
+                                                                        NULL)) {
     if (prerender_manager->prerender_tracker()->TryCancel(
             render_process_id, render_view_id,
             prerender::FINAL_STATUS_SSL_ERROR)) {
diff --git a/chrome/browser/prerender/prerender_browsertest.cc b/chrome/browser/prerender/prerender_browsertest.cc
index e7fba70..5c4866f 100644
--- a/chrome/browser/prerender/prerender_browsertest.cc
+++ b/chrome/browser/prerender/prerender_browsertest.cc
@@ -307,11 +307,12 @@ class TestPrerenderContents : public PrerenderContents {
 
   virtual void AddPendingPrerender(
       base::WeakPtr<PrerenderHandle> weak_prerender_handle,
+      Origin origin,
       const GURL& url,
       const content::Referrer& referrer,
       const gfx::Size& size) OVERRIDE {
     PrerenderContents::AddPendingPrerender(
-        weak_prerender_handle, url, referrer, size);
+        weak_prerender_handle, origin, url, referrer, size);
     if (expected_pending_prerenders_ > 0 &&
         pending_prerenders().size() == expected_pending_prerenders_) {
       MessageLoop::current()->Quit();
diff --git a/chrome/browser/prerender/prerender_contents.cc b/chrome/browser/prerender/prerender_contents.cc
index 3a8e72c..1fa00d9 100644
--- a/chrome/browser/prerender/prerender_contents.cc
+++ b/chrome/browser/prerender/prerender_contents.cc
@@ -169,11 +169,12 @@ class PrerenderContents::TabContentsDelegateImpl
 
 void PrerenderContents::AddPendingPrerender(
     const base::WeakPtr<PrerenderHandle> weak_prerender_handle,
+    const Origin origin,
     const GURL& url,
     const content::Referrer& referrer,
     const gfx::Size& size) {
   pending_prerenders_.push_back(
-      PendingPrerenderInfo(weak_prerender_handle, url, referrer, size));
+      PendingPrerenderInfo(weak_prerender_handle, origin, url, referrer, size));
 }
 
 bool PrerenderContents::IsPendingEntry(
@@ -206,7 +207,7 @@ void PrerenderContents::StartPendingPrerenders() {
        ++it) {
     if (it->weak_prerender_handle && it->weak_prerender_handle->IsValid()) {
       prerender_manager_->StartPendingPrerender(
-          it->weak_prerender_handle.get(), ORIGIN_LINK_REL_PRERENDER, child_id_,
+          it->weak_prerender_handle.get(), it->origin, child_id_,
           it->url, it->referrer, it->size, session_storage_namespace);
     }
   }
@@ -214,10 +215,12 @@ void PrerenderContents::StartPendingPrerenders() {
 
 PrerenderContents::PendingPrerenderInfo::PendingPrerenderInfo(
     const base::WeakPtr<PrerenderHandle> weak_prerender_handle,
+    const Origin origin,
     const GURL& url,
     const content::Referrer& referrer,
     const gfx::Size& size)
     : weak_prerender_handle(weak_prerender_handle),
+      origin(origin),
       url(url),
       referrer(referrer),
       size(size) {
@@ -522,7 +525,7 @@ bool PrerenderContents::AddAliasURL(const GURL& url) {
     return false;
   }
   if (match_complete_status_ != MATCH_COMPLETE_REPLACEMENT_PENDING &&
-      prerender_manager_->HasRecentlyBeenNavigatedTo(url)) {
+      prerender_manager_->HasRecentlyBeenNavigatedTo(origin(), url)) {
     Destroy(FINAL_STATUS_RECENTLY_VISITED);
     return false;
   }
diff --git a/chrome/browser/prerender/prerender_contents.h b/chrome/browser/prerender/prerender_contents.h
index 1277f54..4a46b490 100644
--- a/chrome/browser/prerender/prerender_contents.h
+++ b/chrome/browser/prerender/prerender_contents.h
@@ -14,6 +14,7 @@
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
+#include "chrome/browser/prerender/prerender_origin.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/web_contents_observer.h"
@@ -230,6 +231,7 @@ class PrerenderContents : public content::NotificationObserver,
   // exists when this page is made visible, it will be launched.
   virtual void AddPendingPrerender(
       base::WeakPtr<PrerenderHandle> weak_prerender_handle,
+      Origin origin,
       const GURL& url,
       const content::Referrer& referrer,
       const gfx::Size& size);
@@ -246,12 +248,14 @@ class PrerenderContents : public content::NotificationObserver,
   struct PendingPrerenderInfo {
     PendingPrerenderInfo(
         base::WeakPtr<PrerenderHandle> weak_prerender_handle,
+        Origin origin,
         const GURL& url,
         const content::Referrer& referrer,
         const gfx::Size& size);
     ~PendingPrerenderInfo();
 
     base::WeakPtr<PrerenderHandle> weak_prerender_handle;
+    Origin origin;
     GURL url;
     content::Referrer referrer;
     gfx::Size size;
diff --git a/chrome/browser/prerender/prerender_histograms.cc b/chrome/browser/prerender/prerender_histograms.cc
index 5e75a03..ced90b8 100644
--- a/chrome/browser/prerender/prerender_histograms.cc
+++ b/chrome/browser/prerender/prerender_histograms.cc
@@ -21,8 +21,10 @@ namespace prerender {
 
 namespace {
 
-// Time window for which we will record windowed PLT's from the last
-// observed link rel=prefetch tag.
+// Time window for which we will record windowed PLTs from the last observed
+// link rel=prefetch tag. This is not intended to be the same as the prerender
+// ttl, it's just intended to be a window during which a prerender has likely
+// affected performance.
 const int kWindowDurationSeconds = 30;
 
 std::string ComposeHistogramName(const std::string& prefix_type,
@@ -52,6 +54,8 @@ std::string GetHistogramName(Origin origin, uint8 experiment_id,
       return ComposeHistogramName("omnibox", name);
     case ORIGIN_LINK_REL_PRERENDER:
       return ComposeHistogramName("web", name);
+    case ORIGIN_NONE:
+      return ComposeHistogramName("none", name);
     case ORIGIN_GWS_PRERENDER:  // Handled above.
     default:
       NOTREACHED();
@@ -73,8 +77,8 @@ bool OriginIsOmnibox(Origin origin) {
 // All HISTOGRAM arguments must be UMA_HISTOGRAM... macros that contain an
 // argument "name" which these macros will eventually substitute for the
 // actual name used.
-#define PREFIXED_HISTOGRAM(histogram_name, HISTOGRAM) \
-  PREFIXED_HISTOGRAM_INTERNAL(GetCurrentOrigin(), GetCurrentExperimentId(), \
+#define PREFIXED_HISTOGRAM(histogram_name, origin, HISTOGRAM)           \
+  PREFIXED_HISTOGRAM_INTERNAL(origin, GetCurrentExperimentId(),         \
                               IsOriginExperimentWash(), HISTOGRAM, \
                               histogram_name)
 
@@ -105,6 +109,8 @@ bool OriginIsOmnibox(Origin origin) {
     HISTOGRAM; \
   } else if (origin == ORIGIN_OMNIBOX) { \
     HISTOGRAM; \
+  } else if (origin == ORIGIN_NONE) { \
+    HISTOGRAM; \
   } else if (experiment != kNoExperiment) { \
     HISTOGRAM; \
   } else { \
@@ -178,13 +184,15 @@ void PrerenderHistograms::RecordUsedPrerender(Origin origin) const {
 }
 
 void PrerenderHistograms::RecordTimeSinceLastRecentVisit(
+    Origin origin,
     base::TimeDelta delta) const {
   PREFIXED_HISTOGRAM(
-      "TimeSinceLastRecentVisit",
+      "TimeSinceLastRecentVisit", origin,
       UMA_HISTOGRAM_TIMES(name, delta));
 }
 
 void PrerenderHistograms::RecordFractionPixelsFinalAtSwapin(
+    Origin origin,
     double fraction) const {
   if (fraction < 0.0 || fraction > 1.0)
     return;
@@ -193,7 +201,7 @@ void PrerenderHistograms::RecordFractionPixelsFinalAtSwapin(
     return;
   PREFIXED_HISTOGRAM(
       base::FieldTrial::MakeName("FractionPixelsFinalAtSwapin", "Prerender"),
-      UMA_HISTOGRAM_PERCENTAGE(name, percentage));
+      origin, UMA_HISTOGRAM_PERCENTAGE(name, percentage));
 }
 
 base::TimeTicks PrerenderHistograms::GetCurrentTimeTicks() const {
@@ -203,8 +211,8 @@ base::TimeTicks PrerenderHistograms::GetCurrentTimeTicks() const {
 // Helper macro for histograms.
 #define RECORD_PLT(tag, perceived_page_load_time) { \
   PREFIXED_HISTOGRAM( \
-    base::FieldTrial::MakeName(tag, "Prerender"), \
-    UMA_HISTOGRAM_CUSTOM_TIMES( \
+      base::FieldTrial::MakeName(tag, "Prerender"), origin, \
+      UMA_HISTOGRAM_CUSTOM_TIMES( \
         name, \
         perceived_page_load_time, \
         base::TimeDelta::FromMilliseconds(10), \
@@ -236,7 +244,9 @@ base::TimeTicks PrerenderHistograms::GetCurrentTimeTicks() const {
 // FirstAfterMissNonOverlapping but NOT FirstAfterMiss
 
 void PrerenderHistograms::RecordPerceivedPageLoadTime(
-    base::TimeDelta perceived_page_load_time, bool was_prerender,
+    Origin origin,
+    base::TimeDelta perceived_page_load_time,
+    bool was_prerender,
     bool was_complete_prerender, const GURL& url) {
   if (!IsWebURL(url))
     return;
@@ -286,7 +296,9 @@ void PrerenderHistograms::RecordPerceivedPageLoadTime(
 }
 
 void PrerenderHistograms::RecordPageLoadTimeNotSwappedIn(
-    base::TimeDelta page_load_time, const GURL& url) const {
+    Origin origin,
+    base::TimeDelta page_load_time,
+    const GURL& url) const {
   // If the URL to be prerendered is not a http[s] URL, or is a Google URL,
   // do not record.
   if (!IsWebURL(url) || IsGoogleDomain(url))
@@ -294,24 +306,8 @@ void PrerenderHistograms::RecordPageLoadTimeNotSwappedIn(
   RECORD_PLT("PrerenderNotSwappedInPLT", page_load_time);
 }
 
-void PrerenderHistograms::RecordSimulatedLocalBrowsingBaselinePLT(
-    base::TimeDelta page_load_time, const GURL& url) const {
-  // If the URL to be prerendered is not a http[s] URL do not record.
-  if (!IsWebURL(url))
-    return;
-  RECORD_PLT("SimulatedLocalBrowsingBaselinePLT", page_load_time);
-}
-
-void PrerenderHistograms::RecordSimulatedLocalBrowsingPLT(
-    base::TimeDelta page_load_time, const GURL& url) const {
-  // If the URL to be prerendered is not a http[s] URL do not record.
-  if (!IsWebURL(url))
-    return;
-  RECORD_PLT("SimulatedLocalBrowsingPLT", page_load_time);
-}
-
-void PrerenderHistograms::RecordPercentLoadDoneAtSwapin(double fraction)
-    const {
+void PrerenderHistograms::RecordPercentLoadDoneAtSwapin(Origin origin,
+                                                        double fraction) const {
   if (fraction < 0.0 || fraction > 1.0)
     return;
   int percentage = static_cast<int>(fraction * 100);
@@ -319,7 +315,7 @@ void PrerenderHistograms::RecordPercentLoadDoneAtSwapin(double fraction)
     return;
   PREFIXED_HISTOGRAM(
       base::FieldTrial::MakeName("PercentLoadDoneAtSwapin", "Prerender"),
-      UMA_HISTOGRAM_PERCENTAGE(name, percentage));
+      origin, UMA_HISTOGRAM_PERCENTAGE(name, percentage));
 }
 
 base::TimeDelta PrerenderHistograms::GetTimeSinceLastPrerender() const {
@@ -334,10 +330,11 @@ bool PrerenderHistograms::WithinWindow() const {
 }
 
 void PrerenderHistograms::RecordTimeUntilUsed(
+    Origin origin,
     base::TimeDelta time_until_used,
     base::TimeDelta time_to_live) const {
   PREFIXED_HISTOGRAM(
-      "TimeUntilUsed",
+      "TimeUntilUsed", origin,
       UMA_HISTOGRAM_CUSTOM_TIMES(
           name,
           time_until_used,
@@ -346,16 +343,17 @@ void PrerenderHistograms::RecordTimeUntilUsed(
           50));
 }
 
-void PrerenderHistograms::RecordPerSessionCount(int count) const {
+void PrerenderHistograms::RecordPerSessionCount(Origin origin,
+                                                int count) const {
   PREFIXED_HISTOGRAM(
-      "PrerendersPerSessionCount",
+      "PrerendersPerSessionCount", origin,
       UMA_HISTOGRAM_COUNTS(name, count));
 }
 
 void PrerenderHistograms::RecordTimeBetweenPrerenderRequests(
-    base::TimeDelta time) const {
+    Origin origin, base::TimeDelta time) const {
   PREFIXED_HISTOGRAM(
-      "TimeBetweenPrerenderRequests",
+      "TimeBetweenPrerenderRequests", origin,
       UMA_HISTOGRAM_TIMES(name, time));
 }
 
@@ -389,37 +387,10 @@ uint8 PrerenderHistograms::GetCurrentExperimentId() const {
   return last_experiment_id_;
 }
 
-Origin PrerenderHistograms::GetCurrentOrigin() const {
-  if (!WithinWindow())
-    return ORIGIN_LINK_REL_PRERENDER;
-  return last_origin_;
-}
-
 bool PrerenderHistograms::IsOriginExperimentWash() const {
   if (!WithinWindow())
     return false;
   return origin_experiment_wash_;
 }
 
-void PrerenderHistograms::RecordLocalPredictorEvent(
-    PrerenderLocalPredictor::Event event) const {
-  UMA_HISTOGRAM_ENUMERATION(
-      ComposeHistogramName("", base::FieldTrial::MakeName(
-          "LocalPredictorEvent", "Prerender")),
-      event,
-      PrerenderLocalPredictor::EVENT_MAX_VALUE);
-}
-
-void PrerenderHistograms::RecordLocalPredictorTimeUntilUsed(
-    base::TimeDelta time_until_used, base::TimeDelta max_age) const {
-  PREFIXED_HISTOGRAM(
-      "LocalPredictorTimeUntilUsed",
-      UMA_HISTOGRAM_CUSTOM_TIMES(
-          name,
-          time_until_used,
-          base::TimeDelta::FromMilliseconds(10),
-          max_age,
-          50));
-}
-
 }  // namespace prerender
diff --git a/chrome/browser/prerender/prerender_histograms.h b/chrome/browser/prerender/prerender_histograms.h
index e77802f..df3e4a9 100644
--- a/chrome/browser/prerender/prerender_histograms.h
+++ b/chrome/browser/prerender/prerender_histograms.h
@@ -31,7 +31,8 @@ class PrerenderHistograms {
   // Records the perceived page load time for a page - effectively the time from
   // when the user navigates to a page to when it finishes loading.  The actual
   // load may have started prior to navigation due to prerender hints.
-  void RecordPerceivedPageLoadTime(base::TimeDelta perceived_page_load_time,
+  void RecordPerceivedPageLoadTime(Origin origin,
+                                   base::TimeDelta perceived_page_load_time,
                                    bool was_prerender,
                                    bool was_complete_prerender,
                                    const GURL& url);
@@ -39,33 +40,26 @@ class PrerenderHistograms {
   // Records, in a histogram, the percentage of the page load time that had
   // elapsed by the time it is swapped in.  Values outside of [0, 1.0] are
   // invalid and ignored.
-  void RecordPercentLoadDoneAtSwapin(double fraction) const;
+  void RecordPercentLoadDoneAtSwapin(Origin origin, double fraction) const;
 
   // Records the actual pageload time of a prerender that has not been swapped
   // in yet, but finished loading.
-  void RecordPageLoadTimeNotSwappedIn(base::TimeDelta page_load_time,
+  void RecordPageLoadTimeNotSwappedIn(Origin origin,
+                                      base::TimeDelta page_load_time,
                                       const GURL& url) const;
 
-  // For simulated local browsing prerendering, records the PLT without
-  // any local browsing prerendering.
-  void RecordSimulatedLocalBrowsingBaselinePLT(base::TimeDelta page_load_time,
-                                               const GURL& url) const;
-
-  // For simulated local browsing prerendering, records the PLT with
-  // local browsing prerendering.
-  void RecordSimulatedLocalBrowsingPLT(base::TimeDelta page_load_time,
-                                       const GURL& url) const;
-
   // 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,
+  void RecordTimeUntilUsed(Origin origin,
+                           base::TimeDelta time_until_used,
                            base::TimeDelta time_to_live) const;
 
   // Record a PerSessionCount data point.
-  void RecordPerSessionCount(int count) const;
+  void RecordPerSessionCount(Origin origin, int count) const;
 
   // Record time between two prerender requests.
-  void RecordTimeBetweenPrerenderRequests(base::TimeDelta time) const;
+  void RecordTimeBetweenPrerenderRequests(Origin origin,
+                                          base::TimeDelta time) const;
 
   // Record a final status of a prerendered page in a histogram.
   void RecordFinalStatus(Origin origin,
@@ -87,20 +81,12 @@ class PrerenderHistograms {
   void RecordUsedPrerender(Origin origin) const;
 
   // Record the time since a page was recently visited.
-  void RecordTimeSinceLastRecentVisit(base::TimeDelta time) const;
+  void RecordTimeSinceLastRecentVisit(Origin origin,
+                                      base::TimeDelta time) const;
 
   // Record a percentage of pixels of the final page already in place at
   // swap-in.
-  void RecordFractionPixelsFinalAtSwapin(double fraction) const;
-
-  // Record the occurrence of an event from the local predictor.
-  void RecordLocalPredictorEvent(PrerenderLocalPredictor::Event event) const;
-
-  // For the local predictor, 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 RecordLocalPredictorTimeUntilUsed(base::TimeDelta time_until_used,
-                                         base::TimeDelta max_age) const;
+  void RecordFractionPixelsFinalAtSwapin(Origin origin, double fraction) const;
 
  private:
   base::TimeTicks GetCurrentTimeTicks() const;
@@ -115,8 +101,7 @@ class PrerenderHistograms {
 
   // Returns the current experiment.
   uint8 GetCurrentExperimentId() const;
-  // Returns the current origin.
-  Origin GetCurrentOrigin() const;
+
   // Returns whether or not there is currently an origin/experiment wash.
   bool IsOriginExperimentWash() const;
 
diff --git a/chrome/browser/prerender/prerender_local_predictor.cc b/chrome/browser/prerender/prerender_local_predictor.cc
index 573ea62..3074c00 100644
--- a/chrome/browser/prerender/prerender_local_predictor.cc
+++ b/chrome/browser/prerender/prerender_local_predictor.cc
@@ -9,6 +9,7 @@
 #include <map>
 #include <set>
 
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/timer.h"
 #include "chrome/browser/prerender/prerender_histograms.h"
@@ -200,9 +201,12 @@ void PrerenderLocalPredictor::OnAddVisit(const history::BriefVisitInfo& info) {
   if (current_prerender_.get() &&
       current_prerender_->url_id == info.url_id &&
       IsPrerenderStillValid(current_prerender_.get())) {
-    prerender_manager_->histograms()->RecordLocalPredictorTimeUntilUsed(
+    UMA_HISTOGRAM_CUSTOM_TIMES(
+        "Prerender.LocalPredictorTimeUntilUsed",
         GetCurrentTime() - current_prerender_->actual_start_time,
-        base::TimeDelta::FromMilliseconds(kMaxLocalPredictionTimeMs));
+        base::TimeDelta::FromMilliseconds(10),
+        base::TimeDelta::FromMilliseconds(kMaxLocalPredictionTimeMs),
+        50);
     last_swapped_in_prerender_.reset(current_prerender_.release());
     RecordEvent(EVENT_ADD_VISIT_PRERENDER_IDENTIFIED);
   }
@@ -370,17 +374,23 @@ void PrerenderLocalPredictor::OnPLTEventForURL(const GURL& url,
   if (!prerender.get())
     return;
   if (IsPrerenderStillValid(prerender.get())) {
+    UMA_HISTOGRAM_CUSTOM_TIMES("Prerender.SimulatedLocalBrowsingBaselinePLT",
+                               page_load_time,
+                               base::TimeDelta::FromMilliseconds(10),
+                               base::TimeDelta::FromSeconds(60),
+                               100);
+
     base::TimeDelta prerender_age = GetCurrentTime() - prerender->start_time;
-    prerender_manager_->histograms()->RecordSimulatedLocalBrowsingBaselinePLT(
-        page_load_time, url);
     if (prerender_age > page_load_time) {
       base::TimeDelta new_plt;
       if (prerender_age <  2 * page_load_time)
         new_plt = 2 * page_load_time - prerender_age;
-      prerender_manager_->histograms()->RecordSimulatedLocalBrowsingPLT(
-          new_plt, url);
+      UMA_HISTOGRAM_CUSTOM_TIMES("Prerender.SimulatedLocalBrowsingPLT",
+                                 new_plt,
+                                 base::TimeDelta::FromMilliseconds(10),
+                                 base::TimeDelta::FromSeconds(60),
+                                 100);
     }
-
   }
 }
 
@@ -392,9 +402,11 @@ bool PrerenderLocalPredictor::IsPrerenderStillValid(
           > GetCurrentTime());
 }
 
-void PrerenderLocalPredictor::RecordEvent(PrerenderLocalPredictor::Event event)
-    const {
-  prerender_manager_->histograms()->RecordLocalPredictorEvent(event);
+void PrerenderLocalPredictor::RecordEvent(
+    PrerenderLocalPredictor::Event event) const {
+  UMA_HISTOGRAM_ENUMERATION(
+      base::FieldTrial::MakeName("Prerender.LocalPredictorEvent", "Prerender"),
+      event, PrerenderLocalPredictor::EVENT_MAX_VALUE);
 }
 
 bool PrerenderLocalPredictor::DoesPrerenderMatchPLTRecord(
diff --git a/chrome/browser/prerender/prerender_manager.cc b/chrome/browser/prerender/prerender_manager.cc
index 2282f21..3a89deb 100644
--- a/chrome/browser/prerender/prerender_manager.cc
+++ b/chrome/browser/prerender/prerender_manager.cc
@@ -165,14 +165,25 @@ PrerenderManager::PrerenderManagerMode PrerenderManager::mode_ =
     PRERENDER_MODE_ENABLED;
 
 struct PrerenderManager::NavigationRecord {
-  GURL url_;
-  base::TimeTicks time_;
   NavigationRecord(const GURL& url, base::TimeTicks time)
-      : url_(url),
-        time_(time) {
+      : url(url),
+        time(time) {
   }
+
+  GURL url;
+  base::TimeTicks time;
 };
 
+PrerenderManager::PrerenderedWebContentsData::
+PrerenderedWebContentsData(Origin origin) : origin(origin) {
+}
+
+PrerenderManager::WouldBePrerenderedWebContentsData::
+WouldBePrerenderedWebContentsData(Origin origin)
+    : origin(origin),
+      state(WAITING_FOR_PROVISIONAL_LOAD) {
+}
+
 PrerenderManager::PrerenderManager(Profile* profile,
                                    PrerenderTracker* prerender_tracker)
     : enabled_(true),
@@ -232,7 +243,7 @@ PrerenderHandle* PrerenderManager::AddPrerenderFromLinkRelPrerender(
           new PrerenderHandle(pending_prerender_list_.back().get());
       contents->AddPendingPrerender(
           prerender_handle->weak_ptr_factory_.GetWeakPtr(),
-          url, referrer, size);
+          ORIGIN_LINK_REL_PRERENDER, url, referrer, size);
       return prerender_handle;
     }
   }
@@ -291,7 +302,7 @@ void PrerenderManager::CancelAllPrerenders() {
 bool PrerenderManager::MaybeUsePrerenderedPage(WebContents* web_contents,
                                                const GURL& url) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!IsWebContentsPrerendering(web_contents));
+  DCHECK(!IsWebContentsPrerendering(web_contents, NULL));
 
   DeleteOldEntries();
   DeletePendingDeleteEntries();
@@ -328,7 +339,8 @@ bool PrerenderManager::MaybeUsePrerenderedPage(WebContents* web_contents,
   // that prerendering hasn't even started yet), record that |web_contents| now
   // would be showing a prerendered contents, but otherwise, don't do anything.
   if (!prerender_contents->prerendering_has_started()) {
-    MarkWebContentsAsWouldBePrerendered(web_contents);
+    MarkWebContentsAsWouldBePrerendered(web_contents,
+                                        prerender_contents->origin());
     prerender_contents.release()->Destroy(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
     return false;
   }
@@ -353,7 +365,8 @@ bool PrerenderManager::MaybeUsePrerenderedPage(WebContents* web_contents,
   // 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);
+    MarkWebContentsAsWouldBePrerendered(web_contents,
+                                        prerender_contents->origin());
     prerender_contents.release()->Destroy(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
     return false;
   }
@@ -372,11 +385,13 @@ bool PrerenderManager::MaybeUsePrerenderedPage(WebContents* web_contents,
 
   if (!prerender_contents->load_start_time().is_null()) {
     histograms_->RecordTimeUntilUsed(
+        prerender_contents->origin(),
         GetCurrentTimeTicks() - prerender_contents->load_start_time(),
         config_.time_to_live);
   }
 
-  histograms_->RecordPerSessionCount(++prerenders_per_session_count_);
+  histograms_->RecordPerSessionCount(prerender_contents->origin(),
+                                     ++prerenders_per_session_count_);
   histograms_->RecordUsedPrerender(prerender_contents->origin());
   prerender_contents->set_final_status(FINAL_STATUS_USED);
 
@@ -397,7 +412,8 @@ bool PrerenderManager::MaybeUsePrerenderedPage(WebContents* web_contents,
   DCHECK(new_tab_contents);
   DCHECK(old_tab_contents);
 
-  MarkWebContentsAsPrerendered(new_tab_contents->web_contents());
+  MarkWebContentsAsPrerendered(new_tab_contents->web_contents(),
+                               prerender_contents->origin());
 
   // Merge the browsing history.
   new_tab_contents->web_contents()->GetController().CopyStateFromAndPrune(
@@ -511,25 +527,43 @@ void PrerenderManager::RecordPerceivedPageLoadTime(
     return;
   if (!prerender_manager->IsEnabled())
     return;
-  bool was_prerender =
-      prerender_manager->IsWebContentsPrerendered(web_contents);
-  bool was_complete_prerender = was_prerender ||
-      prerender_manager->WouldWebContentsBePrerendered(web_contents);
-  if (prerender_manager->IsWebContentsPrerendering(web_contents)) {
+
+  Origin prerender_origin = ORIGIN_NONE;
+  if (prerender_manager->IsWebContentsPrerendering(web_contents,
+                                                   &prerender_origin)) {
     prerender_manager->histograms_->RecordPageLoadTimeNotSwappedIn(
-        perceived_page_load_time, url);
-  } else {
-    prerender_manager->histograms_->RecordPerceivedPageLoadTime(
-        perceived_page_load_time, was_prerender, was_complete_prerender, url);
+        prerender_origin, perceived_page_load_time, url);
+    return;
+  }
+
+  bool was_prerender = prerender_manager->IsWebContentsPrerendered(
+      web_contents, &prerender_origin);
+  bool was_complete_prerender = was_prerender ||
+      prerender_manager->WouldWebContentsBePrerendered(web_contents,
+                                                       &prerender_origin);
+  prerender_manager->histograms_->RecordPerceivedPageLoadTime(
+      prerender_origin, perceived_page_load_time, was_prerender,
+      was_complete_prerender, url);
+
+  if (was_prerender) {
     prerender_manager->histograms_->RecordPercentLoadDoneAtSwapin(
-        fraction_plt_elapsed_at_swap_in);
-    if (prerender_manager->local_predictor_.get()) {
-      prerender_manager->local_predictor_->
-          OnPLTEventForURL(url, perceived_page_load_time);
-    }
+        prerender_origin, fraction_plt_elapsed_at_swap_in);
+  }
+  if (prerender_manager->local_predictor_.get()) {
+    prerender_manager->local_predictor_->
+        OnPLTEventForURL(url, perceived_page_load_time);
   }
 }
 
+void PrerenderManager::RecordFractionPixelsFinalAtSwapin(
+    content::WebContents* web_contents,
+    double fraction) {
+  Origin origin = ORIGIN_NONE;
+  bool is_prerendered = IsWebContentsPrerendered(web_contents, &origin);
+  DCHECK(is_prerendered);
+  histograms_->RecordFractionPixelsFinalAtSwapin(origin, fraction);
+}
+
 void PrerenderManager::set_enabled(bool enabled) {
   DCHECK(CalledOnValidThread());
   enabled_ = enabled;
@@ -600,10 +634,15 @@ bool PrerenderManager::IsNoUseGroup() {
 }
 
 bool PrerenderManager::IsWebContentsPrerendering(
-    WebContents* web_contents) const {
+    WebContents* web_contents,
+    Origin* origin) const {
   DCHECK(CalledOnValidThread());
-  if (GetPrerenderContents(web_contents))
+  if (PrerenderContents* prerender_contents =
+          GetPrerenderContents(web_contents)) {
+    if (origin)
+      *origin = prerender_contents->origin();
     return true;
+  }
 
   // Also look through the pending-deletion list.
   for (std::list<PrerenderContents*>::const_iterator it =
@@ -612,8 +651,11 @@ bool PrerenderManager::IsWebContentsPrerendering(
        ++it) {
     TabContents* prerender_tab_contents = (*it)->prerender_contents();
     if (prerender_tab_contents &&
-        prerender_tab_contents->web_contents() == web_contents)
+        prerender_tab_contents->web_contents() == web_contents) {
+      if (origin)
+        *origin = (*it)->origin();
       return true;
+    }
   }
 
   return false;
@@ -636,27 +678,37 @@ PrerenderContents* PrerenderManager::GetPrerenderContents(
   return NULL;
 }
 
-void PrerenderManager::MarkWebContentsAsPrerendered(WebContents* web_contents) {
+void PrerenderManager::MarkWebContentsAsPrerendered(WebContents* web_contents,
+                                                    Origin origin) {
   DCHECK(CalledOnValidThread());
-  prerendered_tab_contents_set_.insert(web_contents);
+  prerendered_web_contents_data_.insert(
+      base::hash_map<content::WebContents*,
+                     PrerenderedWebContentsData>::value_type(
+                         web_contents, PrerenderedWebContentsData(origin)));
 }
 
 void PrerenderManager::MarkWebContentsAsWouldBePrerendered(
-    WebContents* web_contents) {
+    WebContents* web_contents,
+    Origin origin) {
   DCHECK(CalledOnValidThread());
-  would_be_prerendered_map_[web_contents] = true;
+  would_be_prerendered_map_.insert(
+      base::hash_map<content::WebContents*,
+                     WouldBePrerenderedWebContentsData>::value_type(
+                         web_contents,
+                         WouldBePrerenderedWebContentsData(origin)));
 }
 
 void PrerenderManager::MarkWebContentsAsNotPrerendered(
     WebContents* web_contents) {
   DCHECK(CalledOnValidThread());
-  prerendered_tab_contents_set_.erase(web_contents);
-  WouldBePrerenderedMap::iterator it =
-      would_be_prerendered_map_.find(web_contents);
+  prerendered_web_contents_data_.erase(web_contents);
+  base::hash_map<content::WebContents*, WouldBePrerenderedWebContentsData>::
+      iterator it = would_be_prerendered_map_.find(web_contents);
   if (it != would_be_prerendered_map_.end()) {
-    bool first_time = it->second;
-    if (first_time) {
-      it->second = false;
+    if (it->second.state ==
+            WouldBePrerenderedWebContentsData::WAITING_FOR_PROVISIONAL_LOAD) {
+      it->second.state =
+          WouldBePrerenderedWebContentsData::SEEN_PROVISIONAL_LOAD;
     } else {
       would_be_prerendered_map_.erase(it);
     }
@@ -664,18 +716,33 @@ void PrerenderManager::MarkWebContentsAsNotPrerendered(
 }
 
 bool PrerenderManager::IsWebContentsPrerendered(
-    content::WebContents* web_contents) const {
+    content::WebContents* web_contents,
+    Origin* origin) const {
   DCHECK(CalledOnValidThread());
-  return prerendered_tab_contents_set_.count(web_contents) > 0;
+  base::hash_map<content::WebContents*, PrerenderedWebContentsData>::
+      const_iterator it = prerendered_web_contents_data_.find(web_contents);
+  if (it == prerendered_web_contents_data_.end())
+    return false;
+  if (origin)
+    *origin = it->second.origin;
+  return true;
 }
 
 bool PrerenderManager::WouldWebContentsBePrerendered(
-    WebContents* web_contents) const {
+    WebContents* web_contents,
+    Origin* origin) const {
   DCHECK(CalledOnValidThread());
-  return would_be_prerendered_map_.count(web_contents) > 0;
+  base::hash_map<content::WebContents*, WouldBePrerenderedWebContentsData>::
+      const_iterator it = would_be_prerendered_map_.find(web_contents);
+  if (it == would_be_prerendered_map_.end())
+    return false;
+  if (origin)
+    *origin = it->second.origin;
+  return true;
 }
 
-bool PrerenderManager::HasRecentlyBeenNavigatedTo(const GURL& url) {
+bool PrerenderManager::HasRecentlyBeenNavigatedTo(Origin origin,
+                                                  const GURL& url) {
   DCHECK(CalledOnValidThread());
 
   CleanUpOldNavigations();
@@ -684,9 +751,9 @@ bool PrerenderManager::HasRecentlyBeenNavigatedTo(const GURL& url) {
            navigations_.rbegin();
        it != end;
        ++it) {
-    if (it->url_ == url) {
-      base::TimeDelta delta = GetCurrentTimeTicks() - it->time_;
-      histograms_->RecordTimeSinceLastRecentVisit(delta);
+    if (it->url == url) {
+      base::TimeDelta delta = GetCurrentTimeTicks() - it->time;
+      histograms_->RecordTimeSinceLastRecentVisit(origin, delta);
       return true;
     }
   }
@@ -968,7 +1035,7 @@ PrerenderHandle* PrerenderManager::AddPrerender(
 #endif
 
   // Check if enough time has passed since the last prerender.
-  if (!DoesRateLimitAllowPrerender()) {
+  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.
@@ -1171,11 +1238,11 @@ PrerenderManager::FindIteratorForPrerenderContents(
   return active_prerender_list_.end();
 }
 
-bool PrerenderManager::DoesRateLimitAllowPrerender() const {
+bool PrerenderManager::DoesRateLimitAllowPrerender(Origin origin) const {
   DCHECK(CalledOnValidThread());
   base::TimeDelta elapsed_time =
       GetCurrentTimeTicks() - last_prerender_start_time_;
-  histograms_->RecordTimeBetweenPrerenderRequests(elapsed_time);
+  histograms_->RecordTimeBetweenPrerenderRequests(origin, elapsed_time);
   if (!config_.rate_limit_enabled)
     return true;
   return elapsed_time >
@@ -1198,7 +1265,7 @@ void PrerenderManager::CleanUpOldNavigations() {
   base::TimeTicks cutoff = GetCurrentTimeTicks() -
       base::TimeDelta::FromMilliseconds(kNavigationRecordWindowMs);
   while (!navigations_.empty()) {
-    if (navigations_.front().time_ > cutoff)
+    if (navigations_.front().time > cutoff)
       break;
     navigations_.pop_front();
   }
diff --git a/chrome/browser/prerender/prerender_manager.h b/chrome/browser/prerender/prerender_manager.h
index 0245b2c..7faaf5d 100644
--- a/chrome/browser/prerender/prerender_manager.h
+++ b/chrome/browser/prerender/prerender_manager.h
@@ -159,6 +159,11 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
       content::WebContents* web_contents,
       const GURL& url);
 
+  // Records the percentage of pixels of the final page in place at swap-in.
+  void RecordFractionPixelsFinalAtSwapin(
+      content::WebContents* web_contents,
+      double fraction);
+
   // Set whether prerendering is currently enabled for this manager.
   // Must be called on the UI thread.
   // If |enabled| is false, existing prerendered pages will still persist until
@@ -179,8 +184,11 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   static bool IsNoUseGroup();
 
   // Query the list of current prerender pages to see if the given web contents
-  // is prerendering a page.
-  bool IsWebContentsPrerendering(content::WebContents* web_contents) const;
+  // is prerendering a page. The optional parameter |origin| is an output
+  // parameter which, if a prerender is found, is set to the Origin of the
+  // prerender |web_contents|.
+  bool IsWebContentsPrerendering(content::WebContents* web_contents,
+                                 Origin* origin) const;
 
   // Returns the PrerenderContents object for the given web_contents if it's
   // used for an active prerender page, otherwise returns NULL.
@@ -189,14 +197,23 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
 
   // Maintaining and querying the set of WebContents belonging to this
   // PrerenderManager that are currently showing prerendered pages.
-  void MarkWebContentsAsPrerendered(content::WebContents* web_contents);
-  void MarkWebContentsAsWouldBePrerendered(content::WebContents* web_contents);
+  void MarkWebContentsAsPrerendered(content::WebContents* web_contents,
+                                    Origin origin);
+  void MarkWebContentsAsWouldBePrerendered(content::WebContents* web_contents,
+                                           Origin origin);
   void MarkWebContentsAsNotPrerendered(content::WebContents* web_contents);
-  bool IsWebContentsPrerendered(content::WebContents* web_contents) const;
-  bool WouldWebContentsBePrerendered(content::WebContents* web_contents) const;
+
+  // Returns true if |web_contents| was originally a prerender that has since
+  // been swapped in. The optional parameter |origin| is an output parameter
+  // which, if a prerender is found, is set to the Origin of the prerender of
+  // |web_contents|.
+  bool IsWebContentsPrerendered(content::WebContents* web_contents,
+                                Origin* origin) const;
+  bool WouldWebContentsBePrerendered(content::WebContents* web_contents,
+                                     Origin* origin) const;
 
   // Checks whether |url| has been recently navigated to.
-  bool HasRecentlyBeenNavigatedTo(const GURL& url);
+  bool HasRecentlyBeenNavigatedTo(Origin origin, const GURL& url);
 
   // Returns true if the method given is invalid for prerendering.
   static bool IsValidHttpMethod(const std::string& method);
@@ -242,8 +259,6 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
 
   Profile* profile() const { return profile_; }
 
-  PrerenderHistograms* histograms() const { return histograms_.get(); }
-
  protected:
   class PrerenderData : public base::SupportsWeakPtr<PrerenderData> {
    public:
@@ -335,7 +350,36 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   class OnCloseTabContentsDeleter;
   struct NavigationRecord;
 
-  typedef base::hash_map<content::WebContents*, bool> WouldBePrerenderedMap;
+  // For each WebContents that is swapped in, we store a
+  // PrerenderedWebContentsData so that we can track the origin of the
+  // prerender.
+  struct PrerenderedWebContentsData {
+    explicit PrerenderedWebContentsData(Origin origin);
+
+    Origin origin;
+  };
+
+  // In the control group experimental group for each WebContents "not swapped
+  // in" we create a WouldBePrerenderedWebContentsData to the origin of the
+  // "prerender" we did not launch. We also track a state machine to ensure
+  // the histogram reporting tracks what histograms would have done.
+  struct WouldBePrerenderedWebContentsData {
+    // When the WebContents gets a provisional load, we'd like to remove the
+    // WebContents from  the map since the new navigation would not have swapped
+    // in a prerender. But the first provisional load after the control
+    // prerender is not "swapped in" is actually to the prerendered location! So
+    // we don't remove the item from the map on the first provisional load, but
+    // we do for subsequent loads.
+    enum State {
+      WAITING_FOR_PROVISIONAL_LOAD,
+      SEEN_PROVISIONAL_LOAD,
+    };
+
+    explicit WouldBePrerenderedWebContentsData(Origin origin);
+
+    Origin origin;
+    State state;
+  };
 
   // Time interval before a new prerender is allowed.
   static const int kMinTimeBetweenPrerendersMs = 500;
@@ -411,7 +455,7 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   std::list<linked_ptr<PrerenderData> >::iterator
       FindIteratorForPrerenderContents(PrerenderContents* prerender_contents);
 
-  bool DoesRateLimitAllowPrerender() const;
+  bool DoesRateLimitAllowPrerender(Origin origin) const;
 
   // Deletes old WebContents that have been replaced by prerendered ones.  This
   // is needed because they're replaced in a callback from the old WebContents,
@@ -484,8 +528,12 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   // List of prerender elements to be deleted
   std::list<PrerenderContents*> pending_delete_list_;
 
-  // Set of WebContents which are currently displaying a prerendered page.
-  base::hash_set<content::WebContents*> prerendered_tab_contents_set_;
+  // This map is from all WebContents which are currently displaying a
+  // prerendered page which has already been swapped in to a
+  // PrerenderedWebContentsData for tracking full lifetime information
+  // on prerenders.
+  base::hash_map<content::WebContents*, PrerenderedWebContentsData>
+      prerendered_web_contents_data_;
 
   // WebContents that would have been swapped out for a prerendered WebContents
   // if the user was not part of the control group for measurement. When the
@@ -493,10 +541,11 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   // the map since the new navigation would not have swapped in a prerender.
   // However, one complication exists because the first provisional load after
   // the WebContents is marked as "Would Have Been Prerendered" is actually to
-  // the prerendered location. So, we need to keep a boolean around that does
+  // the prerendered location. So, we need to keep a state around that does
   // not clear the item from the map on the first provisional load, but does
   // for subsequent loads.
-  WouldBePrerenderedMap would_be_prerendered_map_;
+  base::hash_map<content::WebContents*, WouldBePrerenderedWebContentsData>
+      would_be_prerendered_map_;
 
   scoped_ptr<PrerenderContents::Factory> prerender_contents_factory_;
 
diff --git a/chrome/browser/prerender/prerender_manager_unittest.cc b/chrome/browser/prerender/prerender_manager_unittest.cc
new file mode 100644
index 0000000..86d6f33
--- /dev/null
+++ b/chrome/browser/prerender/prerender_manager_unittest.cc
@@ -0,0 +1,100 @@
+// 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 "base/message_loop.h"
+#include "chrome/browser/prerender/prerender_manager.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "content/public/test/test_browser_thread.h"
+
+
+namespace prerender {
+
+namespace {
+
+// These tests don't require the dummy PrerenderContents & PrerenderManager that
+// the heavier PrerenderTest.* tests do.
+class PrerenderManagerTest : public testing::Test {
+ public:
+  PrerenderManagerTest()
+      : ui_thread_(content::BrowserThread::UI, &message_loop_),
+        prerender_manager_(NULL, NULL) {
+  }
+
+  PrerenderManager* prerender_manager() { return &prerender_manager_; }
+
+  MessageLoop message_loop_;
+  content::TestBrowserThread ui_thread_;
+  PrerenderManager prerender_manager_;
+};
+
+TEST_F(PrerenderManagerTest, IsWebContentsPrerenderedTest) {
+  // The methods being tested should not dereference their WebContents, instead
+  // they use it as a unique identifier.
+  int not_a_webcontents = 0;
+  content::WebContents* web_contents =
+      reinterpret_cast<content::WebContents*>(&not_a_webcontents);
+
+  EXPECT_FALSE(prerender_manager()->IsWebContentsPrerendered(
+      web_contents, NULL));
+
+  const Origin origin = ORIGIN_OMNIBOX;
+  prerender_manager()->MarkWebContentsAsPrerendered(web_contents, origin);
+
+  Origin test_origin = ORIGIN_NONE;
+  EXPECT_TRUE(prerender_manager()->IsWebContentsPrerendered(
+      web_contents, &test_origin));
+
+  int also_not_a_webcontents = 1;
+  content::WebContents* another_web_contents =
+      reinterpret_cast<content::WebContents*>(&also_not_a_webcontents);
+  EXPECT_FALSE(prerender_manager()->IsWebContentsPrerendered(
+      another_web_contents, NULL));
+
+  EXPECT_EQ(origin, test_origin);
+
+  prerender_manager()->MarkWebContentsAsNotPrerendered(web_contents);
+  EXPECT_FALSE(prerender_manager()->IsWebContentsPrerendered(
+      web_contents, NULL));
+}
+
+TEST_F(PrerenderManagerTest, WouldWebContentsBePrerenderedTest) {
+  // The methods being tested should not dereference their WebContents, instead
+  // they use it as a unique identifier.
+  int not_a_webcontents = 0;
+  content::WebContents* web_contents =
+      reinterpret_cast<content::WebContents*>(&not_a_webcontents);
+
+  EXPECT_FALSE(prerender_manager()->WouldWebContentsBePrerendered(
+      web_contents, NULL));
+
+  const Origin origin = ORIGIN_OMNIBOX;
+  prerender_manager()->MarkWebContentsAsWouldBePrerendered(web_contents,
+                                                           origin);
+
+  Origin test_origin = ORIGIN_NONE;
+  EXPECT_TRUE(prerender_manager()->WouldWebContentsBePrerendered(
+      web_contents, &test_origin));
+  EXPECT_EQ(origin, test_origin);
+
+  int also_not_a_webcontents = 1;
+  content::WebContents* another_web_contents =
+      reinterpret_cast<content::WebContents*>(&also_not_a_webcontents);
+  EXPECT_FALSE(prerender_manager()->WouldWebContentsBePrerendered(
+      another_web_contents, NULL));
+
+  // Control group (aka WouldBe...) web_contents need to be removed twice. See
+  // the comment in prerender_manager.cc at the definition of
+  // WouldBePrerenderedWebContentsData and its inner enum State.
+  prerender_manager()->MarkWebContentsAsNotPrerendered(web_contents);
+  EXPECT_TRUE(prerender_manager()->WouldWebContentsBePrerendered(
+      web_contents, NULL));
+
+  prerender_manager()->MarkWebContentsAsNotPrerendered(web_contents);
+  EXPECT_FALSE(prerender_manager()->WouldWebContentsBePrerendered(
+      web_contents, NULL));
+}
+
+}  // namespace
+
+}  // namespace prerender
diff --git a/chrome/browser/prerender/prerender_origin.cc b/chrome/browser/prerender/prerender_origin.cc
index 084120d..d22a3ad 100644
--- a/chrome/browser/prerender/prerender_origin.cc
+++ b/chrome/browser/prerender/prerender_origin.cc
@@ -18,11 +18,13 @@ const char* kOriginNames[] = {
   "[Deprecated] Omnibox (conservative)",
   "[Deprecated] Omnibox (exact)",
   "Omnibox",
-  "Max"
+  "None",
+  "Max",
 };
 COMPILE_ASSERT(arraysize(kOriginNames) == ORIGIN_MAX + 1,
                PrerenderOrigin_name_count_mismatch);
-}
+
+}  // namespace
 
 const char* NameFromOrigin(Origin origin) {
   DCHECK(static_cast<int>(origin) >= 0 &&
diff --git a/chrome/browser/prerender/prerender_origin.h b/chrome/browser/prerender/prerender_origin.h
index 0c79daa..af5b68e 100644
--- a/chrome/browser/prerender/prerender_origin.h
+++ b/chrome/browser/prerender/prerender_origin.h
@@ -16,7 +16,8 @@ enum Origin {
   // Obsolete: ORIGIN_OMNIBOX_CONSERVATIVE = 3,
   // Obsolete: ORIGIN_OMNIBOX_EXACT = 4,
   ORIGIN_OMNIBOX = 5,
-  ORIGIN_MAX
+  ORIGIN_NONE = 6,
+  ORIGIN_MAX,
 };
 
 // Return a human-readable name for |origin|.
diff --git a/chrome/browser/prerender/prerender_tab_helper.cc b/chrome/browser/prerender/prerender_tab_helper.cc
index 779bd70..06afd3f 100644
--- a/chrome/browser/prerender/prerender_tab_helper.cc
+++ b/chrome/browser/prerender/prerender_tab_helper.cc
@@ -89,8 +89,8 @@ class PrerenderTabHelper::PixelStats {
       PrerenderManager* prerender_manager =
           tab_helper_->MaybeGetPrerenderManager();
       if (prerender_manager) {
-        prerender_manager->histograms()->RecordFractionPixelsFinalAtSwapin(
-            CompareBitmaps(bitmap_.get(), bitmap.get()));
+        prerender_manager->RecordFractionPixelsFinalAtSwapin(
+            web_contents, CompareBitmaps(bitmap_.get(), bitmap.get()));
       }
       bitmap_.reset();
       bitmap_web_contents_ = NULL;
@@ -144,7 +144,7 @@ void PrerenderTabHelper::ProvisionalChangeToMainFrameUrl(
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
     return;
-  if (prerender_manager->IsWebContentsPrerendering(web_contents()))
+  if (prerender_manager->IsWebContentsPrerendering(web_contents(), NULL))
     return;
   prerender_manager->MarkWebContentsAsNotPrerendered(web_contents());
 }
@@ -161,7 +161,7 @@ void PrerenderTabHelper::DidCommitProvisionalLoadForFrame(
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
     return;
-  if (prerender_manager->IsWebContentsPrerendering(web_contents()))
+  if (prerender_manager->IsWebContentsPrerendering(web_contents(), NULL))
     return;
   prerender_manager->RecordNavigation(validated_url);
 }
@@ -221,14 +221,14 @@ bool PrerenderTabHelper::IsPrerendering() {
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
     return false;
-  return prerender_manager->IsWebContentsPrerendering(web_contents());
+  return prerender_manager->IsWebContentsPrerendering(web_contents(), NULL);
 }
 
 bool PrerenderTabHelper::IsPrerendered() {
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
     return false;
-  return prerender_manager->IsWebContentsPrerendered(web_contents());
+  return prerender_manager->IsWebContentsPrerendered(web_contents(), NULL);
 }
 
 void PrerenderTabHelper::PrerenderSwappedIn() {
@@ -240,7 +240,7 @@ void PrerenderTabHelper::PrerenderSwappedIn() {
                                                   web_contents(), url_);
     PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
     if (prerender_manager)
-      prerender_manager->histograms()->RecordFractionPixelsFinalAtSwapin(1.0);
+      prerender_manager->RecordFractionPixelsFinalAtSwapin(web_contents(), 1.0);
   } else {
     // If we have not finished loading yet, record the actual load start, and
     // rebase the start time to now.
diff --git a/chrome/browser/task_manager/task_manager_resource_providers.cc b/chrome/browser/task_manager/task_manager_resource_providers.cc
index 88a0f56..7522af8 100644
--- a/chrome/browser/task_manager/task_manager_resource_providers.cc
+++ b/chrome/browser/task_manager/task_manager_resource_providers.cc
@@ -280,7 +280,7 @@ bool TaskManagerTabContentsResource::IsPrerendering() const {
           tab_contents_->profile());
   return prerender_manager &&
          prerender_manager->IsWebContentsPrerendering(
-             tab_contents_->web_contents());
+             tab_contents_->web_contents(), NULL);
 }
 
 bool TaskManagerTabContentsResource::HostsExtension() const {
diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi
index eeffdb0..b818d5c 100644
--- a/chrome/chrome_tests.gypi
+++ b/chrome/chrome_tests.gypi
@@ -1531,6 +1531,7 @@
         'browser/prefs/scoped_user_pref_update_unittest.cc',
         'browser/prefs/session_startup_pref_unittest.cc',
         'browser/prerender/prerender_history_unittest.cc',
+        'browser/prerender/prerender_manager_unittest.cc',
         'browser/prerender/prerender_tracker_unittest.cc',
         'browser/prerender/prerender_unittest.cc',
         'browser/prerender/prerender_util_unittest.cc',