Make 50% control group for prerendering.

Record pageload time of first page load after a prerender miss,
if it is a non-google domain
R=dominich, cbentzel
Review URL: http://codereview.chromium.org/8124014

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

9 files changed, 63 insertions, 19 deletions

diff --git a/chrome/browser/prerender/prerender_field_trial.cc b/chrome/browser/prerender/prerender_field_trial.cc
index d21cbd6..d7e5495 100644
--- a/chrome/browser/prerender/prerender_field_trial.cc
+++ b/chrome/browser/prerender/prerender_field_trial.cc
@@ -76,10 +76,10 @@ void ConfigurePrefetchAndPrerender(const CommandLine& command_line) {
   switch (prerender_option) {
     case PRERENDER_OPTION_AUTO: {
       const base::FieldTrial::Probability kPrerenderDivisor = 1000;
-      const base::FieldTrial::Probability kPrerenderExp1Probability = 495;
-      const base::FieldTrial::Probability kPrerenderControl1Probability = 5;
-      const base::FieldTrial::Probability kPrerenderExp2Probability = 495;
-      const base::FieldTrial::Probability kPrerenderControl2Probability = 5;
+      const base::FieldTrial::Probability kPrerenderExp1Probability = 250;
+      const base::FieldTrial::Probability kPrerenderControl1Probability = 250;
+      const base::FieldTrial::Probability kPrerenderExp2Probability = 250;
+      const base::FieldTrial::Probability kPrerenderControl2Probability = 250;
       COMPILE_ASSERT(
           kPrerenderExp1Probability + kPrerenderControl1Probability +
           kPrerenderExp2Probability + kPrerenderControl2Probability ==
diff --git a/chrome/browser/prerender/prerender_histograms.cc b/chrome/browser/prerender/prerender_histograms.cc
index 767c7a8..114970c 100644
--- a/chrome/browser/prerender/prerender_histograms.cc
+++ b/chrome/browser/prerender/prerender_histograms.cc
@@ -90,7 +90,9 @@ std::string GetHistogramName(Origin origin, uint8 experiment_id,
 PrerenderHistograms::PrerenderHistograms()
     : last_experiment_id_(kNoExperiment),
       last_origin_(ORIGIN_LINK_REL_PRERENDER),
-      origin_experiment_wash_(false) {
+      origin_experiment_wash_(false),
+      seen_any_pageload_(true),
+      seen_pageload_started_after_prerender_(true) {
 }
 
 void PrerenderHistograms::RecordPrerender(Origin origin, const GURL& url) {
@@ -118,6 +120,8 @@ void PrerenderHistograms::RecordPrerender(Origin origin, const GURL& url) {
   // 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();
+  seen_any_pageload_ = false;
+  seen_pageload_started_after_prerender_ = false;
 }
 
 base::TimeTicks PrerenderHistograms::GetCurrentTimeTicks() const {
@@ -136,25 +140,43 @@ base::TimeTicks PrerenderHistograms::GetCurrentTimeTicks() const {
 }
 
 void PrerenderHistograms::RecordPerceivedPageLoadTime(
-    base::TimeDelta perceived_page_load_time, bool was_prerender) const {
+    base::TimeDelta perceived_page_load_time, bool was_prerender,
+    const GURL& url) {
   bool within_window = WithinWindow();
+  bool is_google_url = IsGoogleDomain(url);
   RECORD_PLT("PerceivedPLT", perceived_page_load_time);
   if (within_window)
     RECORD_PLT("PerceivedPLTWindowed", perceived_page_load_time);
   if (was_prerender) {
     RECORD_PLT("PerceivedPLTMatched", perceived_page_load_time);
-  } else {
-    if (within_window)
-      RECORD_PLT("PerceivedPLTWindowNotMatched", perceived_page_load_time);
+    seen_any_pageload_ = true;
+    seen_pageload_started_after_prerender_ = true;
+  } else if (within_window) {
+    RECORD_PLT("PerceivedPLTWindowNotMatched", perceived_page_load_time);
+    if (!is_google_url) {
+      if (!seen_any_pageload_) {
+        seen_any_pageload_ = true;
+        RECORD_PLT("PerceivedPLTFirstAfterMiss", perceived_page_load_time);
+      }
+      if (!seen_pageload_started_after_prerender_ &&
+          perceived_page_load_time <= GetTimeSinceLastPrerender()) {
+        seen_pageload_started_after_prerender_ = true;
+        RECORD_PLT("PerceivedPLTFirstAfterMissNonOverlapping",
+                   perceived_page_load_time);
+      }
+    }
   }
 }
 
+base::TimeDelta PrerenderHistograms::GetTimeSinceLastPrerender() const {
+  return base::TimeTicks::Now() - last_prerender_seen_time_;
+}
+
 bool PrerenderHistograms::WithinWindow() const {
   if (last_prerender_seen_time_.is_null())
     return false;
-  base::TimeDelta elapsed_time =
-      base::TimeTicks::Now() - last_prerender_seen_time_;
-  return elapsed_time <= base::TimeDelta::FromSeconds(kWindowDurationSeconds);
+  return GetTimeSinceLastPrerender() <=
+      base::TimeDelta::FromSeconds(kWindowDurationSeconds);
 }
 
 
diff --git a/chrome/browser/prerender/prerender_histograms.h b/chrome/browser/prerender/prerender_histograms.h
index 141bfc6..91e6306 100644
--- a/chrome/browser/prerender/prerender_histograms.h
+++ b/chrome/browser/prerender/prerender_histograms.h
@@ -31,7 +31,7 @@ class PrerenderHistograms {
   // 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,
-                                   bool was_prerender) const;
+                                   bool was_prerender, const GURL& url);
 
   // Records the time from when a page starts prerendering to when the user
   // navigates to it. This must be called on the UI thread.
@@ -56,6 +56,9 @@ class PrerenderHistograms {
  private:
   base::TimeTicks GetCurrentTimeTicks() const;
 
+  // Returns the time elapsed since the last prerender happened.
+  base::TimeDelta GetTimeSinceLastPrerender() const;
+
   // Returns whether the PrerenderManager is currently within the prerender
   // window - effectively, up to 30 seconds after a prerender tag has been
   // observed.
@@ -87,6 +90,12 @@ class PrerenderHistograms {
   // from the point that we last saw a <link rel=prerender> tag.
   base::TimeTicks last_prerender_seen_time_;
 
+  // Indicates whether we have recorded page load events after the most
+  // recent prerender.  These must be initialized to true, so that we don't
+  // start recording events before the first prerender occurs.
+  bool seen_any_pageload_;
+  bool seen_pageload_started_after_prerender_;
+
   DISALLOW_COPY_AND_ASSIGN(PrerenderHistograms);
 };
 
diff --git a/chrome/browser/prerender/prerender_manager.cc b/chrome/browser/prerender/prerender_manager.cc
index dbd2647..ba2795e 100644
--- a/chrome/browser/prerender/prerender_manager.cc
+++ b/chrome/browser/prerender/prerender_manager.cc
@@ -674,7 +674,8 @@ void PrerenderManager::DeletePendingDeleteEntries() {
 // static
 void PrerenderManager::RecordPerceivedPageLoadTime(
     base::TimeDelta perceived_page_load_time,
-    TabContents* tab_contents) {
+    TabContents* tab_contents,
+    const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   Profile* profile =
       Profile::FromBrowserContext(tab_contents->browser_context());
@@ -689,7 +690,7 @@ void PrerenderManager::RecordPerceivedPageLoadTime(
        (mode_ == PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP &&
         prerender_manager->IsTabContentsPrerendered(tab_contents)));
   prerender_manager->histograms_->RecordPerceivedPageLoadTime(
-      perceived_page_load_time, was_prerender);
+      perceived_page_load_time, was_prerender, url);
 }
 
 bool PrerenderManager::is_enabled() const {
diff --git a/chrome/browser/prerender/prerender_manager.h b/chrome/browser/prerender/prerender_manager.h
index 7f4d20e..4d12020 100644
--- a/chrome/browser/prerender/prerender_manager.h
+++ b/chrome/browser/prerender/prerender_manager.h
@@ -138,7 +138,8 @@ class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
   // This must be called on the UI thread.
   static void RecordPerceivedPageLoadTime(
       base::TimeDelta perceived_page_load_time,
-      TabContents* tab_contents);
+      TabContents* tab_contents,
+      const GURL& url);
 
   // Returns whether prerendering is currently enabled for this manager.
   // Must be called on the UI thread.
diff --git a/chrome/browser/prerender/prerender_tab_helper.cc b/chrome/browser/prerender/prerender_tab_helper.cc
index 67a963d..6f10593 100644
--- a/chrome/browser/prerender/prerender_tab_helper.cc
+++ b/chrome/browser/prerender/prerender_tab_helper.cc
@@ -189,6 +189,7 @@ void PrerenderTabHelper::ProvisionalChangeToMainFrameUrl(const GURL& url,
   if (prerender_manager->IsTabContentsPrerendering(tab_contents()))
     return;
   prerender_manager->MarkTabContentsAsNotPrerendered(tab_contents());
+  url_ = url;
   MaybeUsePrerenderedPage(url, has_opener_set);
 }
 
@@ -210,7 +211,7 @@ void PrerenderTabHelper::DidStopLoading() {
   // Compute the PPLT metric and report it in a histogram, if needed.
   if (!pplt_load_start_.is_null() && !IsPrerendering()) {
     PrerenderManager::RecordPerceivedPageLoadTime(
-        base::TimeTicks::Now() - pplt_load_start_, tab_contents());
+        base::TimeTicks::Now() - pplt_load_start_, tab_contents(), url_);
   }
 
   // Reset the PPLT metric.
@@ -271,7 +272,7 @@ void PrerenderTabHelper::PrerenderSwappedIn() {
   if (pplt_load_start_.is_null()) {
     // If we have already finished loading, report a 0 PPLT.
     PrerenderManager::RecordPerceivedPageLoadTime(base::TimeDelta(),
-                                                  tab_contents());
+                                                  tab_contents(), url_);
   } else {
     // If we have not finished loading yet, rebase the start time to now.
     pplt_load_start_ = base::TimeTicks::Now();
diff --git a/chrome/browser/prerender/prerender_tab_helper.h b/chrome/browser/prerender/prerender_tab_helper.h
index 89f2b5b..92e3aa8 100644
--- a/chrome/browser/prerender/prerender_tab_helper.h
+++ b/chrome/browser/prerender/prerender_tab_helper.h
@@ -76,6 +76,9 @@ class PrerenderTabHelper : public TabContentsObserver {
   GURL current_hover_url_;
   base::TimeTicks current_hover_time_;
 
+  // Current URL being loaded.
+  GURL url_;
+
   DISALLOW_COPY_AND_ASSIGN(PrerenderTabHelper);
 };
 
diff --git a/chrome/browser/prerender/prerender_util.cc b/chrome/browser/prerender/prerender_util.cc
index 7d1c396..1c0f5b5f 100644
--- a/chrome/browser/prerender/prerender_util.cc
+++ b/chrome/browser/prerender/prerender_util.cc
@@ -62,8 +62,12 @@ uint8 GetQueryStringBasedExperiment(const GURL& url) {
   return kNoExperiment;
 }
 
+bool IsGoogleDomain(const GURL& url) {
+  return StartsWithASCII(url.host(), std::string("www.google."), true);
+}
+
 bool IsGoogleSearchResultURL(const GURL& url) {
-  if (!StartsWithASCII(url.host(), std::string("www.google."), true))
+  if (!IsGoogleDomain(url))
     return false;
   return (url.path().empty() ||
           StartsWithASCII(url.path(), std::string("/search"), true) ||
diff --git a/chrome/browser/prerender/prerender_util.h b/chrome/browser/prerender/prerender_util.h
index 1948475..a53da91 100644
--- a/chrome/browser/prerender/prerender_util.h
+++ b/chrome/browser/prerender/prerender_util.h
@@ -24,6 +24,9 @@ bool MaybeGetQueryStringBasedAliasURL(const GURL& url, GURL* alias_url);
 // is not an integer in the range 1 to 9.
 uint8 GetQueryStringBasedExperiment(const GURL& url);
 
+// Indicates whether the URL provided has a Google domain
+bool IsGoogleDomain(const GURL& url);
+
 // Indicates whether the URL provided could be a Google search result page.
 bool IsGoogleSearchResultURL(const GURL& url);