Fix prerender histograms for multiple prerender case.

chrome/browser/prerender/prerender_local_predictor.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_local_predictor.h"
 
 #include <algorithm>
 #include <ctype.h>
 #include <map>
 #include <set>
 
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/timer.h"
 #include "chrome/browser/prerender/prerender_histograms.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/page_transition_types.h"
@@ skipping 171 matching lines @@
     return;
   visit_history_->push_back(info);
   if (static_cast<int>(visit_history_->size()) > kVisitHistoryPruneThreshold) {
     visit_history_->erase(visit_history_->begin(),
                           visit_history_->begin() + kVisitHistoryPruneAmount);
   }
   RecordEvent(EVENT_ADD_VISIT_INITIALIZED);
   if (current_prerender_.get() &&
       current_prerender_->url_id == info.url_id &&
       IsPrerenderStillValid(current_prerender_.get())) {
-    prerender_manager_->histograms()->RecordLocalPredictorTimeUntilUsed(
+    UMA_HISTOGRAM_CUSTOM_TIMES(
+        "Prerender.LocalPredictorTimeUntilUsed",
         GetCurrentTime() - current_prerender_->actual_start_time,
-        base::TimeDelta::FromMilliseconds(kMaxLocalPredictionTimeMs));
+        base::TimeDelta::FromMilliseconds(10),
+        base::TimeDelta::FromMilliseconds(kMaxLocalPredictionTimeMs),
+        50);
     last_swapped_in_prerender_.reset(current_prerender_.release());
     RecordEvent(EVENT_ADD_VISIT_PRERENDER_IDENTIFIED);
   }
   if (ShouldExcludeTransitionForPrediction(info.transition))
     return;
   RecordEvent(EVENT_ADD_VISIT_RELEVANT_TRANSITION);
   base::TimeDelta max_age =
       base::TimeDelta::FromMilliseconds(kMaxLocalPredictionTimeMs);
   base::TimeDelta min_age =
       base::TimeDelta::FromMilliseconds(kMinLocalPredictionTimeMs);
@@ skipping 147 matching lines @@
                                   url, page_load_time)) {
     prerender.reset(last_swapped_in_prerender_.release());
   }
   if (DoesPrerenderMatchPLTRecord(current_prerender_.get(),
                                   url, page_load_time)) {
     prerender.reset(current_prerender_.release());
   }
   if (!prerender.get())
     return;
   if (IsPrerenderStillValid(prerender.get())) {
+    UMA_HISTOGRAM_CUSTOM_TIMES("Prerender.SimulatedLocalBrowsingBaselinePLT",
+                               page_load_time,
+                               base::TimeDelta::FromMilliseconds(10),
+                               base::TimeDelta::FromSeconds(60),
+                               100);
+
     base::TimeDelta prerender_age = GetCurrentTime() - prerender->start_time;
-    prerender_manager_->histograms()->RecordSimulatedLocalBrowsingBaselinePLT(
-        page_load_time, url);
     if (prerender_age > page_load_time) {
       base::TimeDelta new_plt;
       if (prerender_age <  2 * page_load_time)
         new_plt = 2 * page_load_time - prerender_age;
-      prerender_manager_->histograms()->RecordSimulatedLocalBrowsingPLT(
-          new_plt, url);
+      UMA_HISTOGRAM_CUSTOM_TIMES("Prerender.SimulatedLocalBrowsingPLT",
+                                 new_plt,
+                                 base::TimeDelta::FromMilliseconds(10),
+                                 base::TimeDelta::FromSeconds(60),
+                                 100);
     }
-
   }
 }
 
 bool PrerenderLocalPredictor::IsPrerenderStillValid(
     PrerenderLocalPredictor::PrerenderData* prerender) const {
   return (prerender &&
           (prerender->start_time +
            base::TimeDelta::FromMilliseconds(kMaxLocalPredictionTimeMs))
           > GetCurrentTime());
 }
 
-void PrerenderLocalPredictor::RecordEvent(PrerenderLocalPredictor::Event event)
-    const {
-  prerender_manager_->histograms()->RecordLocalPredictorEvent(event);
+void PrerenderLocalPredictor::RecordEvent(
+    PrerenderLocalPredictor::Event event) const {
+  UMA_HISTOGRAM_ENUMERATION(
+      base::FieldTrial::MakeName("Prerender.LocalPredictorEvent", "Prerender"),
+      event, PrerenderLocalPredictor::EVENT_MAX_VALUE);
 }
 
 bool PrerenderLocalPredictor::DoesPrerenderMatchPLTRecord(
     PrerenderData* prerender, const GURL& url, base::TimeDelta plt) const {
   if (prerender && prerender->start_time < GetCurrentTime() - plt) {
     if (prerender->url.is_empty())
       RecordEvent(EVENT_ERROR_NO_PRERENDER_URL_FOR_PLT);
     return (prerender->url == url);
   } else {
     return false;
   }
 }
 
 bool PrerenderLocalPredictor::ShouldReplaceCurrentPrerender(
     double priority) const {
   base::TimeDelta max_age =
       base::TimeDelta::FromMilliseconds(kMaxLocalPredictionTimeMs);
   return (!current_prerender_.get()) ||
     current_prerender_->priority < priority ||
     current_prerender_->start_time < GetCurrentTime() - max_age;
 }
 
 }  // namespace prerender