[Prerender] Remove the "wash" origin in prerender histograms

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/logging.h"
@@ skipping 31 matching lines @@
 // affected performance.
 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, bool is_wash,
-                             const std::string& name) {
-  if (is_wash)
-    return ComposeHistogramName("wash", name);
-
+std::string GetHistogramName(Origin origin, const std::string& name) {
   switch (origin) {
     case ORIGIN_OMNIBOX:
       return ComposeHistogramName("omnibox", name);
     case ORIGIN_NONE:
       return ComposeHistogramName("none", name);
     case ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN:
       return ComposeHistogramName("websame", name);
     case ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN:
       return ComposeHistogramName("webcross", name);
     case ORIGIN_EXTERNAL_REQUEST:
       return ComposeHistogramName("externalrequest", name);
     case ORIGIN_INSTANT:
       return ComposeHistogramName("Instant", name);
     case ORIGIN_LINK_REL_NEXT:
       return ComposeHistogramName("webnext", name);
     case ORIGIN_GWS_PRERENDER:
       return ComposeHistogramName("gws", name);
     case ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER:
       return ComposeHistogramName("externalrequestforced", name);
     case ORIGIN_OFFLINE:
       return ComposeHistogramName("offline", name);
     default:
       NOTREACHED();
       break;
   }
 
   // Dummy return value to make the compiler happy.
   NOTREACHED();
-  return ComposeHistogramName("wash", name);
+  return ComposeHistogramName("none", name);

[pasko, 2017/03/24 12:45:23]

fun fact: this costs ~26 bytes in android-arm binary :)

 }
 
 bool OriginIsOmnibox(Origin origin) {
   return origin == ORIGIN_OMNIBOX;
 }
 
 const char* FirstContentfulPaintHiddenName(bool was_hidden) {
   return was_hidden ? ".Hidden" : ".Visible";
 }
 
 }  // namespace
 
-// Helper macros for origin-based histogram reporting. All HISTOGRAM arguments
-// must be UMA_HISTOGRAM... macros that contain an argument "name" which these
+// Helper macro for origin-based histogram reporting. All HISTOGRAM arguments
+// must be UMA_HISTOGRAM... macros that contain an argument "name" which this
 // macros will eventually substitute for the actual name used.

[pasko, 2017/03/24 12:45:23]

nit: one more s/macros/macro/

-#define PREFIXED_HISTOGRAM(histogram_name, origin, HISTOGRAM)           \
-  PREFIXED_HISTOGRAM_INTERNAL(origin, IsOriginWash(), HISTOGRAM, histogram_name)
-
-#define PREFIXED_HISTOGRAM_ORIGIN_EXPERIMENT(histogram_name, origin, \
-                                             HISTOGRAM) \
-  PREFIXED_HISTOGRAM_INTERNAL(origin, false, HISTOGRAM, histogram_name)
-
-#define PREFIXED_HISTOGRAM_INTERNAL(origin, wash, HISTOGRAM, histogram_name)  \
+#define PREFIXED_HISTOGRAM(histogram_name, origin, HISTOGRAM)                 \
   do {                                                                        \
     {                                                                         \
       /* Do not rename.  HISTOGRAM expects a local variable "name". */        \
       std::string name = ComposeHistogramName(std::string(), histogram_name); \
       HISTOGRAM;                                                              \
     }                                                                         \
     /* Do not rename.  HISTOGRAM expects a local variable "name". */          \
-    std::string name = GetHistogramName(origin, wash, histogram_name);        \
+    std::string name = GetHistogramName(origin, histogram_name);              \
     /* Branching because HISTOGRAM is caching the histogram into a static. */ \
-    if (wash) {                                                               \
-      HISTOGRAM;                                                              \
-    } else if (origin == ORIGIN_OMNIBOX) {                                    \
+    if (origin == ORIGIN_OMNIBOX) {                                           \
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_NONE) {                                       \
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN) {              \
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN) {             \
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_EXTERNAL_REQUEST) {                           \
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_INSTANT) {                                    \
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_LINK_REL_NEXT) {                              \
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER) {          \
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_OFFLINE) {                                    \
       HISTOGRAM;                                                              \
     } else {                                                                  \
       HISTOGRAM;                                                              \
     }                                                                         \
   } while (0)
 
 PrerenderHistograms::PrerenderHistograms()
-    : last_origin_(ORIGIN_MAX),
-      origin_wash_(false),
-      seen_any_pageload_(true),
-      seen_pageload_started_after_prerender_(true) {
-}
+    : seen_any_pageload_(true), seen_pageload_started_after_prerender_(true) {}
 
-void PrerenderHistograms::RecordPrerender(Origin origin, const GURL& url) {
-  // We need to update last_origin_ and origin_wash_.
-  if (!WithinWindow()) {
-    // If we are outside a window, this is a fresh start and we are fine,
-    // and there is no mix.
-    origin_wash_ = false;
-  } else {
-    // If we are inside the last window, there is a mish mash of origins if
-    // either there was a mish mash before, or the current origin does not match
-    // the previous one.
-    if (origin != last_origin_)
-      origin_wash_ = true;
-  }
-
-  last_origin_ = origin;
-
+void PrerenderHistograms::RecordPrerender() {
   // 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();
   seen_any_pageload_ = false;
   seen_pageload_started_after_prerender_ = false;
 }
 
 void PrerenderHistograms::RecordPrerenderStarted(Origin origin) const {
   if (OriginIsOmnibox(origin)) {
@@ skipping 104 matching lines @@
         }
       }
     }
   }
 }
 
 void PrerenderHistograms::RecordPerceivedFirstContentfulPaintStatus(
     Origin origin,
     bool successful,
     bool was_hidden) {
-  base::UmaHistogramBoolean(
-      GetHistogramName(origin, IsOriginWash(), "PerceivedTTFCPRecorded") +
-          FirstContentfulPaintHiddenName(was_hidden),
-      successful);
+  base::UmaHistogramBoolean(GetHistogramName(origin, "PerceivedTTFCPRecorded") +
+                                FirstContentfulPaintHiddenName(was_hidden),
+                            successful);
 }
 
 void PrerenderHistograms::RecordPageLoadTimeNotSwappedIn(
     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 (!url.SchemeIsHTTPOrHTTPS() ||
       google_util::IsGoogleDomainUrl(url, google_util::DISALLOW_SUBDOMAIN,
@@ skipping 62 matching lines @@
     Origin origin, base::TimeDelta time) const {
   PREFIXED_HISTOGRAM(
       "TimeBetweenPrerenderRequests", origin,
       UMA_HISTOGRAM_TIMES(name, time));
 }
 
 void PrerenderHistograms::RecordFinalStatus(
     Origin origin,
     FinalStatus final_status) const {
   DCHECK(final_status != FINAL_STATUS_MAX);
-  PREFIXED_HISTOGRAM_ORIGIN_EXPERIMENT(
+  PREFIXED_HISTOGRAM(
       "FinalStatus", origin,
       UMA_HISTOGRAM_ENUMERATION(name, final_status, FINAL_STATUS_MAX));
 }
 
 void PrerenderHistograms::RecordNetworkBytes(Origin origin,
                                              bool used,
                                              int64_t prerender_bytes,
                                              int64_t profile_bytes) const {
   const int kHistogramMin = 1;
   const int kHistogramMax = 100000000;  // 100M.
@@ skipping 25 matching lines @@
 
 void PrerenderHistograms::RecordPrefetchResponseReceived(
     Origin origin,
     bool is_main_resource,
     bool is_redirect,
     bool is_no_store) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   int sample = GetResourceType(is_main_resource, is_redirect, is_no_store);
   std::string histogram_name =
-      GetHistogramName(origin, IsOriginWash(), "NoStatePrefetchResponseTypes");
+      GetHistogramName(origin, "NoStatePrefetchResponseTypes");
   base::UmaHistogramExactLinear(histogram_name, sample,
                                 NO_STATE_PREFETCH_RESPONSE_TYPE_COUNT);
 }
 
 void PrerenderHistograms::RecordPrefetchRedirectCount(
     Origin origin,
     bool is_main_resource,
     int redirect_count) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const int kMaxRedirectCount = 10;
   std::string histogram_base_name = base::StringPrintf(
       "NoStatePrefetch%sResourceRedirects", is_main_resource ? "Main" : "Sub");
-  std::string histogram_name =
-      GetHistogramName(origin, IsOriginWash(), histogram_base_name);
+  std::string histogram_name = GetHistogramName(origin, histogram_base_name);
   base::UmaHistogramExactLinear(histogram_name, redirect_count,
                                 kMaxRedirectCount);
 }
 
 void PrerenderHistograms::RecordPrefetchFirstContentfulPaintTime(
     Origin origin,
     bool is_no_store,
     bool was_hidden,
     base::TimeDelta time,
     base::TimeDelta prefetch_age) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!prefetch_age.is_zero()) {
     DCHECK_NE(origin, ORIGIN_NONE);
-    base::UmaHistogramCustomTimes(
-        GetHistogramName(origin, IsOriginWash(), "PrefetchAge"), prefetch_age,
-        base::TimeDelta::FromMilliseconds(10), base::TimeDelta::FromMinutes(30),
-        50);
+    base::UmaHistogramCustomTimes(GetHistogramName(origin, "PrefetchAge"),
+                                  prefetch_age,
+                                  base::TimeDelta::FromMilliseconds(10),
+                                  base::TimeDelta::FromMinutes(30), 50);
   }
 
   std::string histogram_base_name;
   if (prefetch_age.is_zero()) {
     histogram_base_name = "PrefetchTTFCP.Reference";
   } else {
     histogram_base_name = prefetch_age < base::TimeDelta::FromMinutes(
                                              net::HttpCache::kPrefetchReuseMins)
                               ? "PrefetchTTFCP.Warm"
                               : "PrefetchTTFCP.Cold";
   }
 
   histogram_base_name += is_no_store ? ".NoStore" : ".Cacheable";
   histogram_base_name += FirstContentfulPaintHiddenName(was_hidden);
-  std::string histogram_name =
-      GetHistogramName(origin, IsOriginWash(), histogram_base_name);
+  std::string histogram_name = GetHistogramName(origin, histogram_base_name);
 
   base::UmaHistogramCustomTimes(histogram_name, time,
                                 base::TimeDelta::FromMilliseconds(10),
                                 base::TimeDelta::FromMinutes(2), 50);
 }
 
-bool PrerenderHistograms::IsOriginWash() const {
-  if (!WithinWindow())
-    return false;
-  return origin_wash_;
-}
-
 }  // namespace prerender