Add one-time randomization support for FieldTrial, and the ability to

chrome/renderer/page_load_histograms.cc

 // Copyright (c) 2011 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/renderer/page_load_histograms.h"
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
@@ skipping 252 matching lines @@
       PLT_HISTOGRAM("PLT.BeginToFinishDoc_LinkLoadCacheOnly",
            begin_to_finish_doc);
       PLT_HISTOGRAM("PLT.BeginToFinish_LinkLoadCacheOnly",
                     begin_to_finish_all_loads);
       break;
     default:
       break;
   }
 
   // Histograms to determine if DNS prefetching has an impact on PLT.
-  static bool use_dns_histogram(base::FieldTrialList::Find("DnsImpact") &&
-      !base::FieldTrialList::Find("DnsImpact")->group_name().empty());
+  static const bool use_dns_histogram =
+      base::FieldTrialList::TrialExists("DnsImpact");
   if (use_dns_histogram) {
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("PLT.Abandoned", "DnsImpact"),
         abandoned_page ? 1 : 0, 2);
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("PLT.LoadType", "DnsImpact"),
         load_type, NavigationState::kLoadTypeMax);
     switch (load_type) {
       case NavigationState::NORMAL_LOAD:
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
@@ skipping 15 matching lines @@
             "PLT.BeginToFinish_LinkLoadStaleOk", "DnsImpact"),
             begin_to_finish_all_loads);
         break;
       default:
         break;
     }
   }
 
   // Histograms to determine if content prefetching has an impact on PLT.
   static const bool prefetching_fieldtrial =
-      base::FieldTrialList::Find("Prefetch") &&
-      !base::FieldTrialList::Find("Prefetch")->group_name().empty();
+      base::FieldTrialList::TrialExists("Prefetch");
   if (prefetching_fieldtrial) {
     if (navigation_state->was_prefetcher()) {
       PLT_HISTOGRAM(base::FieldTrial::MakeName(
           "PLT.BeginToFinishDoc_ContentPrefetcher", "Prefetch"),
           begin_to_finish_doc);
       PLT_HISTOGRAM(base::FieldTrial::MakeName(
           "PLT.BeginToFinish_ContentPrefetcher", "Prefetch"),
           begin_to_finish_all_loads);
     }
     if (navigation_state->was_referred_by_prefetcher()) {
       PLT_HISTOGRAM(base::FieldTrial::MakeName(
           "PLT.BeginToFinishDoc_ContentPrefetcherReferrer", "Prefetch"),
           begin_to_finish_doc);
       PLT_HISTOGRAM(base::FieldTrial::MakeName(
           "PLT.BeginToFinish_ContentPrefetcherReferrer", "Prefetch"),
           begin_to_finish_all_loads);
     }
     UMA_HISTOGRAM_ENUMERATION(base::FieldTrial::MakeName(
         "PLT.Abandoned", "Prefetch"),
         abandoned_page ? 1 : 0, 2);
     PLT_HISTOGRAM(base::FieldTrial::MakeName(
         "PLT.BeginToFinishDoc", "Prefetch"),
         begin_to_finish_doc);
     PLT_HISTOGRAM(base::FieldTrial::MakeName(
         "PLT.BeginToFinish", "Prefetch"),
         begin_to_finish_all_loads);
   }
 
   // Histograms to determine if backup connection jobs have an impact on PLT.
-  static const bool connect_backup_jobs_fieldtrial(
-      base::FieldTrialList::Find("ConnnectBackupJobs") &&
-      !base::FieldTrialList::Find("ConnnectBackupJobs")->group_name().empty());
+  static const bool connect_backup_jobs_fieldtrial =
+      base::FieldTrialList::TrialExists("ConnnectBackupJobs");
   if (connect_backup_jobs_fieldtrial) {
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("PLT.Abandoned", "ConnnectBackupJobs"),
         abandoned_page ? 1 : 0, 2);
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("PLT.LoadType", "ConnnectBackupJobs"),
         load_type, NavigationState::kLoadTypeMax);
     switch (load_type) {
       case NavigationState::NORMAL_LOAD:
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
@@ skipping 17 matching lines @@
         break;
       default:
         break;
     }
   }
 
   // Histograms to determine if the number of connections has an
   // impact on PLT.
   // TODO(jar): Consider removing the per-link-type versions.  We
   //   really only need LINK_LOAD_NORMAL and NORMAL_LOAD.
-  static bool use_connection_impact_histogram(
-      base::FieldTrialList::Find("ConnCountImpact") &&
-      !base::FieldTrialList::Find("ConnCountImpact")->group_name().empty());
+  static const bool use_connection_impact_histogram =
+      base::FieldTrialList::TrialExists("ConnCountImpact");
   if (use_connection_impact_histogram) {
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("PLT.Abandoned", "ConnCountImpact"),
         abandoned_page ? 1 : 0, 2);
     switch (load_type) {
       case NavigationState::NORMAL_LOAD:
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_NormalLoad", "ConnCountImpact"),
             begin_to_finish_all_loads);
         break;
@@ skipping 11 matching lines @@
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_LinkLoadStaleOk", "ConnCountImpact"),
             begin_to_finish_all_loads);
         break;
       default:
         break;
     }
   }
 
   // Histograms to determine effect of idle socket timeout.
-  static bool use_idle_socket_timeout_histogram(
-      base::FieldTrialList::Find("IdleSktToImpact") &&
-      !base::FieldTrialList::Find("IdleSktToImpact")->group_name().empty());
+  static const bool use_idle_socket_timeout_histogram =
+      base::FieldTrialList::TrialExists("IdleSktToImpact");
   if (use_idle_socket_timeout_histogram) {
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("PLT.Abandoned", "IdleSktToImpact"),
         abandoned_page ? 1 : 0, 2);
     switch (load_type) {
       case NavigationState::NORMAL_LOAD:
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_NormalLoad", "IdleSktToImpact"),
             begin_to_finish_all_loads);
         break;
@@ skipping 11 matching lines @@
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_LinkLoadStaleOk", "IdleSktToImpact"),
             begin_to_finish_all_loads);
         break;
       default:
         break;
     }
   }
 
   // Histograms to determine effect of number of connections per proxy.
-  static bool use_proxy_connection_impact_histogram(
-      base::FieldTrialList::Find("ProxyConnectionImpact") &&
-      !base::FieldTrialList::Find(
-          "ProxyConnectionImpact")->group_name().empty());
+  static const bool use_proxy_connection_impact_histogram =
+      base::FieldTrialList::TrialExists("ProxyConnectionImpact");
   if (use_proxy_connection_impact_histogram) {
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("PLT.Abandoned", "ProxyConnectionImpact"),
         abandoned_page ? 1 : 0, 2);
     switch (load_type) {
       case NavigationState::NORMAL_LOAD:
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_NormalLoad", "ProxyConnectionImpact"),
             begin_to_finish_all_loads);
         break;
@@ skipping 12 matching lines @@
             "PLT.BeginToFinish_LinkLoadStaleOk", "ProxyConnectionImpact"),
             begin_to_finish_all_loads);
         break;
       default:
         break;
     }
   }
 
   // Histograms to determine if SDCH has an impact.
   // TODO(jar): Consider removing per-link load types and the enumeration.
-  static bool use_sdch_histogram(base::FieldTrialList::Find("GlobalSdch") &&
-      !base::FieldTrialList::Find("GlobalSdch")->group_name().empty());
+  static const bool use_sdch_histogram =
+      base::FieldTrialList::TrialExists("GlobalSdch");
   if (use_sdch_histogram) {
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("PLT.LoadType", "GlobalSdch"),
         load_type, NavigationState::kLoadTypeMax);
     switch (load_type) {
       case NavigationState::NORMAL_LOAD:
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_NormalLoad", "GlobalSdch"),
             begin_to_finish_all_loads);
         break;
@@ skipping 16 matching lines @@
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_LinkLoadCacheOnly", "GlobalSdch"),
             begin_to_finish_all_loads);
         break;
       default:
         break;
     }
   }
 
   // Histograms to determine if cache size has an impact on PLT.
-  static bool use_cache_histogram1(base::FieldTrialList::Find("CacheSize") &&
-      !base::FieldTrialList::Find("CacheSize")->group_name().empty());
+  static const bool use_cache_histogram1 =
+      base::FieldTrialList::TrialExists("CacheSize");
   if (use_cache_histogram1 && NavigationState::LINK_LOAD_NORMAL <= load_type &&
       NavigationState::LINK_LOAD_CACHE_ONLY >= load_type) {
     // TODO(mbelshe): Do we really want BeginToFinishDoc here?  It seems like
     //                StartToFinish or BeginToFinish would be better.
     PLT_HISTOGRAM(base::FieldTrial::MakeName(
         "PLT.BeginToFinishDoc_LinkLoad", "CacheSize"), begin_to_finish_doc);
   }
 
   // Histograms to determine if cache throttling has an impact on PLT.
-  static bool use_cache_histogram2(
-      base::FieldTrialList::Find("CacheThrottle") &&
-      !base::FieldTrialList::Find("CacheThrottle")->group_name().empty());
+  static const bool use_cache_histogram2 =
+      base::FieldTrialList::TrialExists("CacheThrottle");
   if (use_cache_histogram2) {
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("PLT.Abandoned", "CacheThrottle"),
         abandoned_page ? 1 : 0, 2);
     switch (load_type) {
       case NavigationState::RELOAD:
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_Reload", "CacheThrottle"),
             begin_to_finish_all_loads);
         break;
@@ skipping 37 matching lines @@
            begin_to_finish_all_loads);
     }
   }
 
   // For the SPDY field trials, we need to verify that the page loaded was
   // the type we requested:
   //   if we asked for a SPDY request, we got a SPDY request
   //   if we asked for a HTTP request, we got a HTTP request
   // Due to spdy version mismatches, it is possible that we ask for SPDY
   // but didn't get SPDY.
-  static bool use_spdy_histogram(base::FieldTrialList::Find("SpdyImpact") &&
-      !base::FieldTrialList::Find("SpdyImpact")->group_name().empty());
+  static const bool use_spdy_histogram =
+      base::FieldTrialList::TrialExists("SpdyImpact");
   if (use_spdy_histogram) {
     // We take extra effort to only compute these once.
     static bool in_spdy_trial = base::FieldTrialList::Find(
         "SpdyImpact")->group_name() == "npn_with_spdy";
     static bool in_http_trial = base::FieldTrialList::Find(
         "SpdyImpact")->group_name() == "npn_with_http";
 
     bool spdy_trial_success = navigation_state->was_fetched_via_spdy() ?
         in_spdy_trial : in_http_trial;
     if (spdy_trial_success) {
@@ skipping 136 matching lines @@
                                 abandoned_page ? 1 : 0, 2);
     } else {
       DCHECK(scheme_type == URLPattern::SCHEME_HTTP);
       PLT_HISTOGRAM("PLT.StartToFinish.NoProxy.http",
                     start_to_finish_all_loads);
       UMA_HISTOGRAM_ENUMERATION("PLT.Abandoned.NoProxy.http",
                                 abandoned_page ? 1 : 0, 2);
     }
   }
 
-  static bool false_start_trial(base::FieldTrialList::Find("SSLFalseStart") &&
-      !base::FieldTrialList::Find("SSLFalseStart")->group_name().empty());
+  static const bool false_start_trial =
+      base::FieldTrialList::TrialExists("SSLFalseStart");
   if (false_start_trial) {
     if (scheme_type == URLPattern::SCHEME_HTTPS) {
       switch (load_type) {
         case NavigationState::LINK_LOAD_NORMAL:
           PLT_HISTOGRAM(base::FieldTrial::MakeName(
               "PLT.BeginToFinish_LinkLoadNormal", "SSLFalseStart"),
               begin_to_finish_all_loads);
           break;
         case NavigationState::NORMAL_LOAD:
           PLT_HISTOGRAM(base::FieldTrial::MakeName(
@@ skipping 74 matching lines @@
 
   DCHECK(state);
   DCHECK(ds);
   GURL url(ds->request().url());
   Time start = state->start_load_time();
   Time finish = state->finish_load_time();
   // TODO(mbelshe): should we log more stats?
   VLOG(1) << "PLT: " << (finish - start).InMilliseconds() << "ms "
           << url.spec();
 }