Fix prerender histograms for multiple prerender case.

chrome/browser/prerender/prerender_histograms.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_histograms.h"
 
 #include <string>
 
 #include "base/format_macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/predictors/autocomplete_action_predictor.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_util.h"
 
 using predictors::AutocompleteActionPredictor;
 
 namespace prerender {
 
 namespace {
 
-// Time window for which we will record windowed PLT's from the last
-// observed link rel=prefetch tag.
-const int kWindowDurationSeconds = 30;
-
 std::string ComposeHistogramName(const std::string& prefix_type,
                                  const std::string& name) {
   if (prefix_type.empty())
     return std::string("Prerender.") + name;
   return std::string("Prerender.") + prefix_type + std::string("_") + name;
 }
 
 std::string GetHistogramName(Origin origin, uint8 experiment_id,
                              bool is_wash, const std::string& name) {
   if (is_wash)
     return ComposeHistogramName("wash", name);
 
   if (origin == ORIGIN_GWS_PRERENDER) {
     if (experiment_id == kNoExperiment)
       return ComposeHistogramName("gws", name);
     return ComposeHistogramName("exp" + std::string(1, experiment_id + '0'),
                                 name);
   }
 
   if (experiment_id != kNoExperiment)
     return ComposeHistogramName("wash", name);
 
   switch (origin) {
     case ORIGIN_OMNIBOX:
       return ComposeHistogramName("omnibox", name);
     case ORIGIN_LINK_REL_PRERENDER:
       return ComposeHistogramName("web", name);
+    case ORIGIN_LOCAL_PREDICTOR:
+      return ComposeHistogramName("local", name);
+    case ORIGIN_NONE:
+      return ComposeHistogramName("none", name);
     case ORIGIN_GWS_PRERENDER:  // Handled above.
     default:
       NOTREACHED();
       break;
   };
 
   // Dummy return value to make the compiler happy.
   NOTREACHED();
   return ComposeHistogramName("wash", name);
 }
 
 bool OriginIsOmnibox(Origin origin) {
   return origin == ORIGIN_OMNIBOX;
 }
 
 }  // namespace
 
 // Helper macros for experiment-based and origin-based histogram reporting.
 // 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)
 
 #define PREFIXED_HISTOGRAM_ORIGIN_EXPERIMENT(histogram_name, origin, \
                                              experiment, HISTOGRAM) \
   PREFIXED_HISTOGRAM_INTERNAL(origin, experiment, false, HISTOGRAM, \
                               histogram_name)
 
 #define PREFIXED_HISTOGRAM_INTERNAL(origin, experiment, wash, HISTOGRAM, \
                                     histogram_name) { \
@@ skipping 17 matching lines @@
     HISTOGRAM; \
   } else if (origin == ORIGIN_OMNIBOX) { \
     HISTOGRAM; \
   } else if (experiment != kNoExperiment) { \
     HISTOGRAM; \
   } else { \
     HISTOGRAM; \
   } \
 }
 
-PrerenderHistograms::PrerenderHistograms()
+PrerenderHistograms::PrerenderHistograms(base::TimeDelta prerender_ttl)
     : last_experiment_id_(kNoExperiment),
       last_origin_(ORIGIN_LINK_REL_PRERENDER),
       origin_experiment_wash_(false),
+      prerender_ttl_(prerender_ttl),
       seen_any_pageload_(true),
       seen_pageload_started_after_prerender_(true) {
 }
 
 void PrerenderHistograms::RecordPrerender(Origin origin, const GURL& url) {
   // Check if we are doing an experiment.
   uint8 experiment = GetQueryStringBasedExperiment(url);
 
   // We need to update last_experiment_id_, last_origin_, and
   // origin_experiment_wash_.
@@ skipping 42 matching lines @@
 
 void PrerenderHistograms::RecordUsedPrerender(Origin origin) const {
   if (OriginIsOmnibox(origin)) {
     UMA_HISTOGRAM_ENUMERATION(
         StringPrintf("Prerender.OmniboxNavigationsUsedPrerenderCount%s",
                      PrerenderManager::GetModeString()), 1, 2);
   }
 }
 
 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;
   int percentage = static_cast<int>(fraction * 100);
   if (percentage < 0 || percentage > 100)
     return;
   PREFIXED_HISTOGRAM(
       base::FieldTrial::MakeName("FractionPixelsFinalAtSwapin", "Prerender"),
-      UMA_HISTOGRAM_PERCENTAGE(name, percentage));
+      origin, UMA_HISTOGRAM_PERCENTAGE(name, percentage));
 }
 
 base::TimeTicks PrerenderHistograms::GetCurrentTimeTicks() const {
   return base::TimeTicks::Now();
 }
 
 // Helper macro for histograms.
 #define RECORD_PLT(tag, perceived_page_load_time) { \
   PREFIXED_HISTOGRAM( \
-    base::FieldTrial::MakeName(tag, "Prerender"), \
+      base::FieldTrial::MakeName(tag, "Prerender"), origin, \
     UMA_HISTOGRAM_CUSTOM_TIMES( \
         name, \
         perceived_page_load_time, \
         base::TimeDelta::FromMilliseconds(10), \
         base::TimeDelta::FromSeconds(60), \
         100)); \
 }
 
 // Summary of all histograms Perceived PLT histograms:
 // (all prefixed PerceivedPLT)
@@ skipping 12 matching lines @@
 // triggering for the first page to finish after the prerender that also started
 // after the prerender started.
 // ...FirstAfterMissBoth -- pages meeting
 // FirstAfterMiss AND FirstAfterMissNonOverlapping
 // ...FirstAfterMissAnyOnly -- pages meeting
 // FirstAfterMiss but NOT FirstAfterMissNonOverlapping
 // ..FirstAfterMissNonOverlappingOnly -- pages meeting
 // 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;
   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 || was_complete_prerender) {
     if (was_prerender)
@@ skipping 29 matching lines @@
         } else if (recorded_non_overlapping) {
           RECORD_PLT("PerceivedPLTFirstAfterMissNonOverlappingOnly",
                      perceived_page_load_time);
         }
       }
     }
   }
 }
 
 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))
     return;
   RECORD_PLT("PrerenderNotSwappedInPLT", page_load_time);
 }
 
 void PrerenderHistograms::RecordSimulatedLocalBrowsingBaselinePLT(
-    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 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 {
+    Origin origin,
+    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);
   if (percentage < 0 || percentage > 100)
     return;
   PREFIXED_HISTOGRAM(
       base::FieldTrial::MakeName("PercentLoadDoneAtSwapin", "Prerender"),
-      UMA_HISTOGRAM_PERCENTAGE(name, percentage));
+      origin, UMA_HISTOGRAM_PERCENTAGE(name, percentage));
 }
 
 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;
-  return GetTimeSinceLastPrerender() <=
-      base::TimeDelta::FromSeconds(kWindowDurationSeconds);
+  return GetTimeSinceLastPrerender() <= prerender_ttl_;
 }
 
 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,
           base::TimeDelta::FromMilliseconds(10),
           time_to_live,
           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));
 }
 
 void PrerenderHistograms::RecordFinalStatus(
     Origin origin,
     uint8 experiment_id,
     PrerenderContents::MatchCompleteStatus mc_status,
     FinalStatus final_status) const {
   DCHECK(final_status != FINAL_STATUS_MAX);
 
@@ skipping 13 matching lines @@
         UMA_HISTOGRAM_ENUMERATION(name, final_status, FINAL_STATUS_MAX));
   }
 }
 
 uint8 PrerenderHistograms::GetCurrentExperimentId() const {
   if (!WithinWindow())
     return kNoExperiment;
   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 {
+    Origin origin,

[mmenke, 2012/10/08 18:20:07]

The function name kinda implies the origin.  Think renaming it to
"RecordSimulatedLocalBrowsingTimeUntilUsed" would make the most sense, and could
put it next to the corresponding PLT functions as well.

+    base::TimeDelta time_until_used,
+    base::TimeDelta max_age) const {
   PREFIXED_HISTOGRAM(
-      "LocalPredictorTimeUntilUsed",
+      "LocalPredictorTimeUntilUsed", origin,
       UMA_HISTOGRAM_CUSTOM_TIMES(
           name,
           time_until_used,
           base::TimeDelta::FromMilliseconds(10),
           max_age,
           50));
 }
 
 }  // namespace prerender