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 123 matching lines @@
     } 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) {
-}
+    : last_origin_(ORIGIN_MAX), origin_wash_(false) {}
 
 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;
 
   // 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)) {
     UMA_HISTOGRAM_ENUMERATION(
         "Prerender.OmniboxPrerenderCount", 1, 2);
   }
 }
 
 void PrerenderHistograms::RecordConcurrency(size_t prerender_count) const {
@@ skipping 17 matching lines @@
     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) {
   base::UmaHistogramBoolean(
       GetHistogramName(origin, IsOriginWash(), "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));
 }
@@ skipping 155 matching lines @@
                                 base::TimeDelta::FromMinutes(2), 50);
 }
 
 bool PrerenderHistograms::IsOriginWash() const {
   if (!WithinWindow())
     return false;
   return origin_wash_;
 }
 
 }  // namespace prerender