Turn some field trial debug instrumentation into a trial.

base/metrics/field_trial.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 "base/metrics/field_trial.h"
 
 #include <algorithm>
 
 #include "base/build_time.h"
 #include "base/lazy_instance.h"
@@ skipping 111 matching lines @@
 // might be multiple FieldTrialList objects.
 // TODO(asvitkine): Remove when crbug.com/359406 is resolved.
 base::LazyInstance<std::map<std::string, std::string>>::Leaky g_seen_states =
     LAZY_INSTANCE_INITIALIZER;
 
 // A debug token generated during FieldTrialList construction. Used to diagnose
 // crbug.com/359406.
 // TODO(asvitkine): Remove when crbug.com/359406 is resolved.
 int32_t g_debug_token = -1;
 
+// Whether to append the debug token to the child process --force-fieldtrials
+// command line. Used to diagnose crbug.com/359406.
+// TODO(asvitkine): Remove when crbug.com/359406 is resolved.
+bool g_append_debug_token_to_trial_string = false;
+
 // Tracks whether |g_seen_states| is used. Defaults to false, because unit tests
 // will create multiple FieldTrialList instances. Also controls whether
 // |g_debug_token| is included in the field trial state string.
 bool g_use_global_check_states = false;
 
 }  // namespace
 
 // statics
 const int FieldTrial::kNotFinalized = -1;
 const int FieldTrial::kDefaultGroupNumber = 0;
@@ skipping 88 matching lines @@
   if (forced_)
     return;
 
   // And we must finalize the group choice before we mark ourselves as forced.
   FinalizeGroupChoice();
   forced_ = true;
 }
 
 // static
 void FieldTrial::EnableBenchmarking() {
-  DCHECK_EQ(0u, FieldTrialList::GetFieldTrialCount());
+  // TODO(asvitkine): Change this back to 0u after the trial in FieldTrialList
+  // constructor is removed.
+  DCHECK_EQ(1u, FieldTrialList::GetFieldTrialCount());
   enable_benchmarking_ = true;
 }
 
 // static
 FieldTrial* FieldTrial::CreateSimulatedFieldTrial(
     const std::string& trial_name,
     Probability total_probability,
     const std::string& default_group_name,
     double entropy_value) {
   return new FieldTrial(trial_name, total_probability, default_group_name,
@@ skipping 88 matching lines @@
           ObserverListBase<FieldTrialList::Observer>::NOTIFY_EXISTING_ONLY)) {
   // TODO(asvitkine): Turn into a DCHECK after http://crbug.com/359406 is fixed.
   CHECK(!global_);
   DCHECK(!used_without_global_);
   global_ = this;
 
   Time two_years_from_build_time = GetBuildTime() + TimeDelta::FromDays(730);
   Time::Exploded exploded;
   two_years_from_build_time.LocalExplode(&exploded);
   kNoExpirationYear = exploded.year;
+
+  // Run a 50/50 experiment that enables |g_use_global_check_states| only for
+  // half the users, to investigate if this instrumentation is causing the
+  // crashes to disappear for http://crbug.com/359406. Done here instead of a
+  // server-side trial because this needs to be done early during FieldTrialList
+  // initialization.
+  //
+  // Note: |g_use_global_check_states| is set via EnableGlobalStateChecks()
+  // prior to the FieldTrialList being created. We only want to do the trial
+  // check once the first time FieldTrialList is created, so use a static
+  // |first_time| variable to track this.
+  //
+  // TODO(asvitkine): Remove after http://crbug.com/359406 is fixed.
+  static bool first_time = true;
+  if (first_time && g_use_global_check_states) {
+    first_time = false;
+    base::FieldTrial* trial =
+        FactoryGetFieldTrial("UMA_CheckStates", 100, "NoChecks",
+                             kNoExpirationYear, 1, 1,
+                             FieldTrial::SESSION_RANDOMIZED, nullptr);
+    trial->AppendGroup("Checks", 50);
+    if (trial->group_name() == "NoChecks")
+      g_use_global_check_states = false;
+  }
 }
 
 FieldTrialList::~FieldTrialList() {
   AutoLock auto_lock(lock_);
   while (!registered_.empty()) {
     RegistrationMap::iterator it = registered_.begin();
     it->second->Release();
     registered_.erase(it->first);
   }
   DCHECK_EQ(this, global_);
   global_ = NULL;
 }
 
 // static
 void FieldTrialList::EnableGlobalStateChecks() {
   CHECK(!g_use_global_check_states);
   g_use_global_check_states = true;
+  g_append_debug_token_to_trial_string = true;
 }
 
 // static
 int32_t FieldTrialList::GetDebugToken() {
   return g_debug_token;
 }
 
 // static
 FieldTrial* FieldTrialList::FactoryGetFieldTrial(
     const std::string& trial_name,
@@ skipping 116 matching lines @@
        it != active_groups.end(); ++it) {
     DCHECK_EQ(std::string::npos,
               it->trial_name.find(kPersistentStringSeparator));
     DCHECK_EQ(std::string::npos,
               it->group_name.find(kPersistentStringSeparator));
     output->append(it->trial_name);
     output->append(1, kPersistentStringSeparator);
     output->append(it->group_name);
     output->append(1, kPersistentStringSeparator);
   }
-  if (g_use_global_check_states) {
+  if (g_append_debug_token_to_trial_string) {
     output->append("DebugToken");
     output->append(1, kPersistentStringSeparator);
     output->append(IntToString(g_debug_token));
     output->append(1, kPersistentStringSeparator);
   }
 }
 
 // static
 void FieldTrialList::AllStatesToString(std::string* output) {
   if (!global_)
@@ skipping 194 matching lines @@
     return;
   }
   AutoLock auto_lock(global_->lock_);
   CHECK(!global_->PreLockedFind(trial->trial_name())) << trial->trial_name();
   trial->AddRef();
   trial->SetTrialRegistered();
   global_->registered_[trial->trial_name()] = trial;
 }
 
 }  // namespace base