More instrumentation to diagnose an Android renderer crash.

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"
 #include "base/logging.h"
 #include "base/rand_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 
 namespace base {
 
 namespace {
 
 // Define a separator character to use when creating a persistent form of an
 // instance.  This is intended for use as a command line argument, passed to a
@@ skipping 93 matching lines @@
   }
 }
 
 // A second copy of FieldTrialList::seen_states_ that is meant to outlive the
 // FieldTrialList object to determine if the inconsistency happens because there
 // 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;
+
 // Tracks whether |g_seen_states| is used. Defaults to false, because unit tests
-// will create multiple FieldTrialList instances.
+// 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;
 bool FieldTrial::enable_benchmarking_ = false;
 
 int FieldTrialList::kNoExpirationYear = 0;
@@ skipping 117 matching lines @@
       accumulated_group_probability_(0),
       next_group_number_(kDefaultGroupNumber + 1),
       group_(kNotFinalized),
       enable_field_trial_(true),
       forced_(false),
       group_reported_(false),
       trial_registered_(false) {
   DCHECK_GT(total_probability, 0);
   DCHECK(!trial_name_.empty());
   DCHECK(!default_group_name_.empty());
+
+  if (g_debug_token == -1)
+    g_debug_token = RandInt(1, INT32_MAX);
 }
 
 FieldTrial::~FieldTrial() {}
 
 void FieldTrial::SetTrialRegistered() {
   DCHECK_EQ(kNotFinalized, group_);
   DCHECK(!trial_registered_);
   trial_registered_ = true;
 }
 
@@ skipping 74 matching lines @@
   global_ = NULL;
 }
 
 // static
 void FieldTrialList::EnableGlobalStateChecks() {
   CHECK(!g_use_global_check_states);
   g_use_global_check_states = true;
 }
 
 // static
+int32_t FieldTrialList::GetDebugToken() {
+  return g_debug_token;
+}
+
+// static
 FieldTrial* FieldTrialList::FactoryGetFieldTrial(
     const std::string& trial_name,
     FieldTrial::Probability total_probability,
     const std::string& default_group_name,
     const int year,
     const int month,
     const int day_of_month,
     FieldTrial::RandomizationType randomization_type,
     int* default_group_number) {
   return FactoryGetFieldTrialWithRandomizationSeed(
@@ skipping 108 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) {
+    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_)
     return;
   AutoLock auto_lock(global_->lock_);
 
   for (const auto& registered : global_->registered_) {
     FieldTrial::State trial;
@@ skipping 189 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