Prerender: Remove PerceivedPLT 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 18 matching lines @@
   REDIRECT = 1 << 1,
   MAIN_RESOURCE = 1 << 2,
   NO_STATE_PREFETCH_RESPONSE_TYPE_COUNT = 1 << 3
 };
 
 int GetResourceType(bool is_main_resource, bool is_redirect, bool is_no_store) {
   return (is_no_store * NO_STORE) + (is_redirect * REDIRECT) +
          (is_main_resource * MAIN_RESOURCE);
 }
 
-// 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;
   return std::string("Prerender.") + prefix_type + std::string("_") + name;
 }
 
 std::string GetHistogramName(Origin origin, const std::string& name) {
   switch (origin) {
     case ORIGIN_OMNIBOX:
@@ skipping 65 matching lines @@
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER) {          \
       HISTOGRAM;                                                              \
     } else if (origin == ORIGIN_OFFLINE) {                                    \
       HISTOGRAM;                                                              \
     } else {                                                                  \
       HISTOGRAM;                                                              \
     }                                                                         \
   } while (0)
 
-PrerenderHistograms::PrerenderHistograms()
-    : seen_any_pageload_(true), seen_pageload_started_after_prerender_(true) {}
-
-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;
-}
+PrerenderHistograms::PrerenderHistograms() {}
 
 void PrerenderHistograms::RecordPrerenderStarted(Origin origin) const {
   if (OriginIsOmnibox(origin)) {
     UMA_HISTOGRAM_ENUMERATION(
         "Prerender.OmniboxPrerenderCount", 1, 2);
   }
 }
 
-void PrerenderHistograms::RecordConcurrency(size_t prerender_count) const {
-  static const size_t kMaxRecordableConcurrency = 20;
-  DCHECK_GE(kMaxRecordableConcurrency, Config().max_link_concurrency);
-  UMA_HISTOGRAM_ENUMERATION(
-      base::StringPrintf("Prerender.PrerenderCountOf%" PRIuS "Max",
-                         kMaxRecordableConcurrency),
-      prerender_count, kMaxRecordableConcurrency + 1);
-}
-
 void PrerenderHistograms::RecordUsedPrerender(Origin origin) const {
   if (OriginIsOmnibox(origin)) {
     UMA_HISTOGRAM_ENUMERATION(
         "Prerender.OmniboxNavigationsUsedPrerenderCount", 1, 2);
   }
 }
 
 void PrerenderHistograms::RecordTimeSinceLastRecentVisit(
     Origin origin,
     base::TimeDelta delta) const {
   PREFIXED_HISTOGRAM(
       "TimeSinceLastRecentVisit", origin,
       UMA_HISTOGRAM_TIMES(name, delta));
 }
 
-base::TimeTicks PrerenderHistograms::GetCurrentTimeTicks() const {
-  return base::TimeTicks::Now();
-}
-
-// Helper macro for histograms.
-#define RECORD_PLT(tag, perceived_page_load_time) \
-  PREFIXED_HISTOGRAM( \
-      tag, 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)
-// PerceivedPLT -- Perceived Pageloadtimes (PPLT) for all pages in the group.
-// ...Windowed -- PPLT for pages in the 30s after a prerender is created.
-// ...FirstAfterMiss -- First page to finish loading after a prerender, which
-// is different from the page that was prerendered.
-// ...FirstAfterMissNonOverlapping -- Same as FirstAfterMiss, but only
-// 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(
-    Origin origin,
-    base::TimeDelta perceived_page_load_time,
-    NavigationType navigation_type,
-    const GURL& url) {
-  if (!url.SchemeIsHTTPOrHTTPS())
-    return;
-  bool within_window = WithinWindow();
-  bool is_google_url =
-      google_util::IsGoogleDomainUrl(url, google_util::DISALLOW_SUBDOMAIN,
-                                     google_util::ALLOW_NON_STANDARD_PORTS);
-  RECORD_PLT("PerceivedPLT", perceived_page_load_time);
-  if (within_window)
-    RECORD_PLT("PerceivedPLTWindowed", perceived_page_load_time);
-  if (navigation_type != NAVIGATION_TYPE_NORMAL) {
-    DCHECK(navigation_type == NAVIGATION_TYPE_PRERENDERED);
-    seen_any_pageload_ = true;
-    seen_pageload_started_after_prerender_ = true;
-  } else if (within_window) {
-    if (!is_google_url) {
-      bool recorded_any = false;
-      bool recorded_non_overlapping = false;
-      if (!seen_any_pageload_) {
-        seen_any_pageload_ = true;
-        RECORD_PLT("PerceivedPLTFirstAfterMiss", perceived_page_load_time);
-        recorded_any = true;
-      }
-      if (!seen_pageload_started_after_prerender_ &&
-          perceived_page_load_time <= GetTimeSinceLastPrerender()) {
-        seen_pageload_started_after_prerender_ = true;
-        RECORD_PLT("PerceivedPLTFirstAfterMissNonOverlapping",
-                   perceived_page_load_time);
-        recorded_non_overlapping = true;
-      }
-      if (recorded_any || recorded_non_overlapping) {
-        if (recorded_any && recorded_non_overlapping) {
-          RECORD_PLT("PerceivedPLTFirstAfterMissBoth",
-                     perceived_page_load_time);
-        } else if (recorded_any) {
-          RECORD_PLT("PerceivedPLTFirstAfterMissAnyOnly",
-                     perceived_page_load_time);
-        } else if (recorded_non_overlapping) {
-          RECORD_PLT("PerceivedPLTFirstAfterMissNonOverlappingOnly",
-                     perceived_page_load_time);
-        }
-      }
-    }
-  }
-}
-
 void PrerenderHistograms::RecordPerceivedFirstContentfulPaintStatus(
     Origin origin,
     bool successful,
-    bool was_hidden) {
+    bool was_hidden) const {
   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,
-                                     google_util::ALLOW_NON_STANDARD_PORTS)) {
-    return;
-  }
-  RECORD_PLT("PrerenderNotSwappedInPLT", page_load_time);
-}
-
 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("PercentLoadDoneAtSwapin",
                      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);
-}
-
 void PrerenderHistograms::RecordTimeUntilUsed(
     Origin origin,
     base::TimeDelta time_until_used) const {
   PREFIXED_HISTOGRAM(
       "TimeUntilUsed2", origin,
       UMA_HISTOGRAM_CUSTOM_TIMES(
           name,
           time_until_used,
           base::TimeDelta::FromMilliseconds(10),
           base::TimeDelta::FromMinutes(30),
@@ skipping 94 matching lines @@
   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) {
+    base::TimeDelta prefetch_age) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!prefetch_age.is_zero()) {
     DCHECK_NE(origin, ORIGIN_NONE);
     base::UmaHistogramCustomTimes(GetHistogramName(origin, "PrefetchAge"),
                                   prefetch_age,
                                   base::TimeDelta::FromMilliseconds(10),
                                   base::TimeDelta::FromMinutes(30), 50);
   }
 
@@ skipping 10 matching lines @@
   histogram_base_name += is_no_store ? ".NoStore" : ".Cacheable";
   histogram_base_name += FirstContentfulPaintHiddenName(was_hidden);
   std::string histogram_name = GetHistogramName(origin, histogram_base_name);
 
   base::UmaHistogramCustomTimes(histogram_name, time,
                                 base::TimeDelta::FromMilliseconds(10),
                                 base::TimeDelta::FromMinutes(2), 50);
 }
 
 }  // namespace prerender