[NoStatePrefetch] Add performance 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"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_util.h"
+#include "net/http/http_cache.h"
 
 namespace prerender {
 
 namespace {
 
 // This enum is used to define the buckets for the
 // "Prerender.NoStatePrefetchResourceCount" histogram family.
 // Hence, existing enumerated constants should never be deleted or reordered,
 // and new constants should only be appended at the end of the enumeration.
 enum NoStatePrefetchResponseType {
@@ skipping 14 matching lines @@
 void RecordHistogramEnum(std::string histogram_name,
                          base::HistogramBase::Sample sample,
                          base::HistogramBase::Sample bucket_count) {
   DCHECK_LT(sample, bucket_count);
   base::HistogramBase* histogram_pointer = base::LinearHistogram::FactoryGet(
       histogram_name, 1, bucket_count, bucket_count + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram_pointer->Add(sample);
 }
 
+// Similar to UMA_HISTOGRAM_CUSTOM_TIMES but allows a dynamic histogram name.
+void RecordHistogramTime(std::string histogram_name,
+                         base::TimeDelta time_min,
+                         base::TimeDelta time_max,
+                         base::TimeDelta sample,
+                         base::HistogramBase::Sample bucket_count) {
+  base::HistogramBase* histogram_pointer = base::Histogram::FactoryTimeGet(
+      histogram_name, time_min, time_max, bucket_count,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  histogram_pointer->AddTime(sample);
+}
+
 // 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,
                                  const std::string& name) {
   if (prefix_type.empty())
     return std::string("Prerender.") + name;
@@ skipping 372 matching lines @@
   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);
   RecordHistogramEnum(histogram_name, redirect_count, kMaxRedirectCount);
 }
 
+void PrerenderHistograms::RecordFirstContentfulPaint(
+    Origin origin,
+    bool is_no_store,
+    base::TimeDelta time,
+    base::TimeDelta prefetch_age) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  std::string histogram_base_name;
+  if (prefetch_age.is_zero()) {
+    histogram_base_name = "NoStatePrefetchTTFCPReference";
+  } else {
+    DCHECK_NE(origin, ORIGIN_NONE);
+
+    RecordHistogramTime(GetHistogramName(origin, IsOriginWash(),
+                                         "Prerender.NoStatePrefetchAge"),
+                        base::TimeDelta::FromMilliseconds(10),
+                        base::TimeDelta::FromMinutes(30), prefetch_age, 50);
+
+    histogram_base_name = prefetch_age < base::TimeDelta::FromMinutes(
+                                             net::HttpCache::kPrefetchReuseMins)
+                              ? "NoStatePrefetchTTFCPWithoutRevalidation"

[mattcary, 2016/09/14 12:33:21]

So do we know positively that revalidation actually happens as soon as we cross
this time? If not, then a more clear histogram name might be
*WithinPrefetchReuse or *OutsidePrefetchReuse, or similar.

[droger, 2016/09/14 14:15:42]

I assume that your concern is that being outside that time window does not mean
that revalidation actually happens, because there are resources that don't need
revalidation at all (or under a different time window).

In this case, you're right that my naming is not great.

"OutsidePrefetchReuse" may be better (as it parallels the constant name) but
also not great, because the prefetch can still be reused even outside of the
window (for resources that don't need revalidation, but even for all resources
since revalidation is cheaper than a full fetch).

What about Warm/Cold (i.e. NoStatePrefetchTTFCPWarm and
NoStatePrefetchTTFCPCold) or Fresh/Old?

[mattcary, 2016/09/14 14:19:39]

Yes, exactly.
SGTM

+                              : "NoStatePrefetchTTFCPWithRevalidation";
+  }
+
+  histogram_base_name += is_no_store ? "NoStore" : "Cacheable";
+
+  RecordHistogramTime(
+      GetHistogramName(origin, IsOriginWash(), histogram_base_name),
+      base::TimeDelta::FromMilliseconds(10), base::TimeDelta::FromMinutes(2),
+      time, 100);
+}
+
 bool PrerenderHistograms::IsOriginWash() const {
   if (!WithinWindow())
     return false;
   return origin_wash_;
 }
 
 }  // namespace prerender