diff options
-rw-r--r-- | base/metrics/OWNERS | 1 | ||||
-rw-r--r-- | base/metrics/field_trial.cc | 98 | ||||
-rw-r--r-- | base/metrics/field_trial.h | 115 | ||||
-rw-r--r-- | base/metrics/field_trial_unittest.cc | 125 | ||||
-rw-r--r-- | base/rand_util.cc | 6 | ||||
-rw-r--r-- | base/rand_util.h | 4 | ||||
-rw-r--r-- | chrome/browser/browser_main.cc | 142 | ||||
-rw-r--r-- | chrome/browser/browser_main.h | 26 | ||||
-rw-r--r-- | chrome/browser/metrics/metrics_service.cc | 4 | ||||
-rw-r--r-- | chrome/browser/metrics/metrics_service.h | 4 | ||||
-rw-r--r-- | chrome/renderer/page_load_histograms.cc | 49 | ||||
-rw-r--r-- | chrome/renderer/prerender/prerender_helper.cc | 3 | ||||
-rw-r--r-- | content/renderer/renderer_main.cc | 6 | ||||
-rw-r--r-- | net/base/host_resolver_impl.cc | 10 | ||||
-rw-r--r-- | net/http/http_cache_transaction.cc | 3 | ||||
-rw-r--r-- | net/http/http_network_transaction.cc | 9 | ||||
-rw-r--r-- | net/socket/client_socket_pool_histograms.cc | 8 | ||||
-rw-r--r-- | net/socket/ssl_client_socket_pool.cc | 5 | ||||
-rw-r--r-- | net/socket/stream_socket.cc | 5 | ||||
-rw-r--r-- | net/url_request/url_request_http_job.cc | 3 |
20 files changed, 454 insertions, 172 deletions
diff --git a/base/metrics/OWNERS b/base/metrics/OWNERS new file mode 100644 index 0000000..8b39a54 --- /dev/null +++ b/base/metrics/OWNERS @@ -0,0 +1 @@ +jar@chromium.org diff --git a/base/metrics/field_trial.cc b/base/metrics/field_trial.cc index 03e5809..b86b9cc 100644 --- a/base/metrics/field_trial.cc +++ b/base/metrics/field_trial.cc @@ -6,6 +6,8 @@ #include "base/logging.h" #include "base/rand_util.h" +#include "base/sha1.h" +#include "base/string_util.h" #include "base/stringprintf.h" #include "base/utf_string_conversions.h" @@ -41,11 +43,13 @@ FieldTrial::FieldTrial(const std::string& name, : name_(name), divisor_(total_probability), default_group_name_(default_group_name), - random_(static_cast<Probability>(divisor_ * base::RandDouble())), + random_(static_cast<Probability>(divisor_ * RandDouble())), accumulated_group_probability_(0), - next_group_number_(kDefaultGroupNumber+1), - group_(kNotFinalized) { + next_group_number_(kDefaultGroupNumber + 1), + group_(kNotFinalized), + enable_field_trial_(true) { DCHECK_GT(total_probability, 0); + DCHECK(!name_.empty()); DCHECK(!default_group_name_.empty()); FieldTrialList::Register(this); @@ -55,7 +59,7 @@ FieldTrial::FieldTrial(const std::string& name, DCHECK_GT(day_of_month, 0); DCHECK_LT(day_of_month, 32); - base::Time::Exploded exploded; + Time::Exploded exploded; exploded.year = year; exploded.month = month; exploded.day_of_week = 0; // Should be unused. @@ -65,8 +69,33 @@ FieldTrial::FieldTrial(const std::string& name, exploded.second = 0; exploded.millisecond = 0; - base::Time expiration_time = Time::FromLocalExploded(exploded); - disable_field_trial_ = (GetBuildTime() > expiration_time) ? true : false; + Time expiration_time = Time::FromLocalExploded(exploded); + if (GetBuildTime() > expiration_time) + Disable(); +} + +void FieldTrial::UseOneTimeRandomization() { + DCHECK_EQ(group_, kNotFinalized); + DCHECK_EQ(kDefaultGroupNumber + 1, next_group_number_); + if (!FieldTrialList::IsOneTimeRandomizationEnabled()) { + NOTREACHED(); + Disable(); + return; + } + + random_ = static_cast<Probability>( + divisor_ * HashClientId(FieldTrialList::client_id(), name_)); +} + +void FieldTrial::Disable() { + enable_field_trial_ = false; + + // In case we are disabled after initialization, we need to switch + // the trial to the default group. + if (group_ != kNotFinalized) { + group_ = kDefaultGroupNumber; + group_name_ = default_group_name_; + } } int FieldTrial::AppendGroup(const std::string& name, @@ -74,7 +103,7 @@ int FieldTrial::AppendGroup(const std::string& name, DCHECK_LE(group_probability, divisor_); DCHECK_GE(group_probability, 0); - if (enable_benchmarking_ || disable_field_trial_) + if (enable_benchmarking_ || !enable_field_trial_) group_probability = 0; accumulated_group_probability_ += group_probability; @@ -84,7 +113,7 @@ int FieldTrial::AppendGroup(const std::string& name, // This is the group that crossed the random line, so we do the assignment. group_ = next_group_number_; if (name.empty()) - base::StringAppendF(&group_name_, "%d", group_); + StringAppendF(&group_name_, "%d", group_); else group_name_ = name; FieldTrialList::NotifyFieldTrialGroupSelection(name_, group_name_); @@ -103,7 +132,8 @@ int FieldTrial::group() { } std::string FieldTrial::group_name() { - group(); // call group() to make group assignment was done. + group(); // call group() to make sure group assignment was done. + DCHECK(!group_name_.empty()); return group_name_; } @@ -133,6 +163,25 @@ Time FieldTrial::GetBuildTime() { return integral_build_time; } +// static +double FieldTrial::HashClientId(const std::string& client_id, + const std::string& trial_name) { + // SHA-1 is designed to produce a uniformly random spread in its output space, + // even for nearly-identical inputs, so it helps massage whatever client_id + // and trial_name we get into something with a uniform distribution, which + // is desirable so that we don't skew any part of the 0-100% spectrum. + std::string input(client_id + trial_name); + unsigned char sha1_hash[SHA1_LENGTH]; + SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()), + input.size(), + sha1_hash); + + COMPILE_ASSERT(sizeof(uint64) < sizeof(sha1_hash), need_more_data); + uint64* bits = reinterpret_cast<uint64*>(&sha1_hash[0]); + + return BitsToOpenEndedUnitInterval(*bits); +} + //------------------------------------------------------------------------------ // FieldTrialList methods and members. @@ -142,8 +191,9 @@ FieldTrialList* FieldTrialList::global_ = NULL; // static bool FieldTrialList::register_without_global_ = false; -FieldTrialList::FieldTrialList() +FieldTrialList::FieldTrialList(const std::string& client_id) : application_start_time_(TimeTicks::Now()), + client_id_(client_id), observer_list_(ObserverList<Observer>::NOTIFY_EXISTING_ONLY) { DCHECK(!global_); DCHECK(!register_without_global_); @@ -204,19 +254,23 @@ std::string FieldTrialList::FindFullName(const std::string& name) { } // static +bool FieldTrialList::TrialExists(const std::string& name) { + return Find(name) != NULL; +} + +// static void FieldTrialList::StatesToString(std::string* output) { if (!global_) return; DCHECK(output->empty()); AutoLock auto_lock(global_->lock_); + for (RegistrationList::iterator it = global_->registered_.begin(); it != global_->registered_.end(); ++it) { const std::string name = it->first; std::string group_name = it->second->group_name_internal(); if (group_name.empty()) - // No definitive winner in this trial, use default_group_name as the - // group_name. - group_name = it->second->default_group_name(); + continue; // Should not include uninitialized trials. DCHECK_EQ(name.find(kPersistentStringSeparator), std::string::npos); DCHECK_EQ(group_name.find(kPersistentStringSeparator), std::string::npos); output->append(name); @@ -313,6 +367,24 @@ size_t FieldTrialList::GetFieldTrialCount() { return global_->registered_.size(); } +// static +bool FieldTrialList::IsOneTimeRandomizationEnabled() { + DCHECK(global_); + if (!global_) + return false; + + return !global_->client_id_.empty(); +} + +// static +const std::string& FieldTrialList::client_id() { + DCHECK(global_); + if (!global_) + return EmptyString(); + + return global_->client_id_; +} + FieldTrial* FieldTrialList::PreLockedFind(const std::string& name) { RegistrationList::iterator it = registered_.find(name); if (registered_.end() == it) diff --git a/base/metrics/field_trial.h b/base/metrics/field_trial.h index b8ab0c5..4e89ccf 100644 --- a/base/metrics/field_trial.h +++ b/base/metrics/field_trial.h @@ -13,12 +13,13 @@ // pseudo-randomly selected). // // States are typically generated randomly, either based on a one time -// randomization (generated randomly once, and then persistently reused in the -// client during each future run of the program), or by a startup randomization -// (generated each time the application starts up, but held constant during the -// duration of the process), or by continuous randomization across a run (where -// the state can be recalculated again and again, many times during a process). -// Only startup randomization is implemented thus far. +// randomization (which will yield the same results, in terms of selecting +// the client for a field trial or not, for every run of the program on a +// given machine), or by a startup randomization (generated each time the +// application starts up, but held constant during the duration of the +// process), or by continuous randomization across a run (where the state +// can be recalculated again and again, many times during a process). +// Continuous randomization is not yet implemented. //------------------------------------------------------------------------------ // Example: Suppose we have an experiment involving memory, such as determining @@ -52,10 +53,9 @@ // to randomly be assigned: // HISTOGRAM_COUNTS("Memory.RendererTotal", count); // The original histogram. -// static bool use_memoryexperiment_histogram( -// base::FieldTrialList::Find("MemoryExperiment") && -// !base::FieldTrialList::Find("MemoryExperiment")->group_name().empty()); -// if (use_memoryexperiment_histogram) { +// static const bool memory_renderer_total_trial_exists = +// FieldTrialList::TrialExists("Memory.RendererTotal"); +// if (memory_renderer_total_trial_exists) { // HISTOGRAM_COUNTS(FieldTrial::MakeName("Memory.RendererTotal", // "MemoryExperiment"), count); // } @@ -103,15 +103,35 @@ class BASE_API FieldTrial : public RefCounted<FieldTrial> { // The name is used to register the instance with the FieldTrialList class, // and can be used to find the trial (only one trial can be present for each - // name). + // name). |name| and |default_group_name| may not be empty. + // // Group probabilities that are later supplied must sum to less than or equal // to the total_probability. Arguments year, month and day_of_month specify // the expiration time. If the build time is after the expiration time then // the field trial reverts to the 'default' group. + // + // Using this constructor creates a startup-randomized FieldTrial. If you + // want a one-time randomized trial, call UseOneTimeRandomization() right + // after construction. FieldTrial(const std::string& name, Probability total_probability, const std::string& default_group_name, const int year, const int month, const int day_of_month); + // Changes the field trial to use one-time randomization, i.e. produce the + // same result for the current trial on every run of this client. Must be + // called right after construction. + // + // Before using this method, |FieldTrialList::EnableOneTimeRandomization()| + // must be called exactly once. + void UseOneTimeRandomization(); + + // Disables this trial, meaning it always determines the default group + // has been selected. May be called immediately after construction, or + // at any time after initialization (should not be interleaved with + // AppendGroup calls). Once disabled, there is no way to re-enable a + // trial. + void Disable(); + // Establish the name and probability of the next group in this trial. // Sometimes, based on construction randomization, this call may cause the // provided group to be *THE* group selected for use in this instance. @@ -124,18 +144,17 @@ class BASE_API FieldTrial : public RefCounted<FieldTrial> { // Return the randomly selected group number that was assigned. // Return kDefaultGroupNumber if the instance is in the 'default' group. // Note that this will force an instance to participate, and make it illegal - // to attempt to probabalistically add any other groups to the trial. + // to attempt to probabilistically add any other groups to the trial. int group(); - // If the field trial is not in an experiment, this returns the empty string. - // if the group's name is empty, a name of "_" concatenated with the group + // If the group's name is empty, a string version containing the group // number is used as the group name. std::string group_name(); // Return the default group name of the FieldTrial. std::string default_group_name() const { return default_group_name_; } - // Helper function for the most common use: as an argument to specifiy the + // Helper function for the most common use: as an argument to specify the // name of a HISTOGRAM. Use the original histogram name as the name_prefix. static std::string MakeName(const std::string& name_prefix, const std::string& trial_name); @@ -155,6 +174,9 @@ class BASE_API FieldTrial : public RefCounted<FieldTrial> { FRIEND_TEST(FieldTrialTest, Save); FRIEND_TEST(FieldTrialTest, DuplicateRestore); FRIEND_TEST(FieldTrialTest, MakeName); + FRIEND_TEST(FieldTrialTest, HashClientId); + FRIEND_TEST(FieldTrialTest, HashClientIdIsUniform); + FRIEND_TEST(FieldTrialTest, UseOneTimeRandomization); friend class base::FieldTrialList; @@ -168,8 +190,13 @@ class BASE_API FieldTrial : public RefCounted<FieldTrial> { // Get build time. static Time GetBuildTime(); + // Calculates a uniformly-distributed double between [0.0, 1.0) given + // a |client_id| and a |trial_name| (the latter is used as salt to avoid + // separate one-time randomized trials from all having the same results). + static double HashClientId(const std::string& client_id, + const std::string& trial_name); + // The name of the field trial, as can be found via the FieldTrialList. - // This is empty of the trial is not in the experiment. const std::string name_; // The maximum sum of all probabilities supplied, which corresponds to 100%. @@ -182,7 +209,7 @@ class BASE_API FieldTrial : public RefCounted<FieldTrial> { // The randomly selected probability that is used to select a group (or have // the instance not participate). It is the product of divisor_ and a random // number between [0, 1). - const Probability random_; + Probability random_; // Sum of the probabilities of all appended groups. Probability accumulated_group_probability_; @@ -193,13 +220,13 @@ class BASE_API FieldTrial : public RefCounted<FieldTrial> { // This is kNotFinalized if no group has been assigned. int group_; - // A textual name for the randomly selected group. If this Trial is not a - // member of an group, this string is empty. + // A textual name for the randomly selected group. Valid after |group()| + // has been called. std::string group_name_; - // When disable_field_trial_ is true, field trial reverts to the 'default' + // When enable_field_trial_ is false, field trial reverts to the 'default' // group. - bool disable_field_trial_; + bool enable_field_trial_; // When benchmarking is enabled, field trials all revert to the 'default' // group. @@ -234,7 +261,12 @@ class BASE_API FieldTrialList { }; // This singleton holds the global list of registered FieldTrials. - FieldTrialList(); + // + // |client_id| should be an opaque, diverse ID for this client that does not + // change between sessions, to enable one-time randomized trials. The empty + // string may be provided, in which case one-time randomized trials will + // not be available. + explicit FieldTrialList(const std::string& client_id); // Destructor Release()'s references to all registered FieldTrial instances. ~FieldTrialList(); @@ -246,15 +278,22 @@ class BASE_API FieldTrialList { // registered, or to retrieve a pointer to it from the global map. static FieldTrial* Find(const std::string& name); + // Returns the group number chosen for the named trial, or + // FieldTrial::kNotFinalized if the trial does not exist. static int FindValue(const std::string& name); + // Returns the group name chosen for the named trial, or the + // empty string if the trial does not exist. static std::string FindFullName(const std::string& name); - // Create a persistent representation of all FieldTrial instances for - // resurrection in another process. This allows randomization to be done in - // one process, and secondary processes can by synchronized on the result. - // The resulting string contains only the names, the trial name, and a "/" - // separator. + // Returns true if the named trial has been registered. + static bool TrialExists(const std::string& name); + + // Create a persistent representation of all FieldTrial instances and the + // |client_id()| state for resurrection in another process. This allows + // randomization to be done in one process, and secondary processes can by + // synchronized on the result. The resulting string contains the + // |client_id()|, the names, the trial name, and a "/" separator. static void StatesToString(std::string* output); // Use a previously generated state string (re: StatesToString()) augment the @@ -263,7 +302,9 @@ class BASE_API FieldTrialList { // is commonly used in a non-browser process, to carry randomly selected state // in a browser process into this non-browser process. This method calls // CreateFieldTrial to create the FieldTrial in the non-browser process. - // Currently only the group_name_ and name_ are restored. + // Currently only the group_name_ and name_ are restored, as well as the + // |client_id()| state, that could be used for one-time randomized trials + // set up only in child processes. static bool CreateTrialsInChildProcess(const std::string& prior_trials); // Create a FieldTrial with the given |name| and using 100% probability for @@ -303,6 +344,17 @@ class BASE_API FieldTrialList { // Return the number of active field trials. static size_t GetFieldTrialCount(); + // Returns true if you can call |FieldTrial::UseOneTimeRandomization()| + // without error, i.e. if a non-empty string was provided as the client_id + // when constructing the FieldTrialList singleton. + static bool IsOneTimeRandomizationEnabled(); + + // Returns an opaque, diverse ID for this client that does not change + // between sessions. + // + // Returns the empty string if one-time randomization is not enabled. + static const std::string& client_id(); + private: // A map from FieldTrial names to the actual instances. typedef std::map<std::string, FieldTrial*> RegistrationList; @@ -317,7 +369,7 @@ class BASE_API FieldTrialList { // is created after that. static bool register_without_global_; - // A helper value made availabel to users, that shows when the FieldTrialList + // A helper value made available to users, that shows when the FieldTrialList // was initialized. Note that this is a singleton instance, and hence is a // good approximation to the start of the process. TimeTicks application_start_time_; @@ -326,6 +378,10 @@ class BASE_API FieldTrialList { base::Lock lock_; RegistrationList registered_; + // An opaque, diverse ID for this client that does not change + // between sessions, or the empty string if not initialized. + std::string client_id_; + // List of observers to be notified when a group is selected for a FieldTrial. ObserverList<Observer> observer_list_; @@ -335,4 +391,3 @@ class BASE_API FieldTrialList { } // namespace base #endif // BASE_METRICS_FIELD_TRIAL_H_ - diff --git a/base/metrics/field_trial_unittest.cc b/base/metrics/field_trial_unittest.cc index 3357085..a790add 100644 --- a/base/metrics/field_trial_unittest.cc +++ b/base/metrics/field_trial_unittest.cc @@ -6,14 +6,18 @@ #include "base/metrics/field_trial.h" +#include "base/rand_util.h" #include "base/stringprintf.h" +#include "base/string_number_conversions.h" #include "testing/gtest/include/gtest/gtest.h" +#include <limits> + namespace base { class FieldTrialTest : public testing::Test { public: - FieldTrialTest() : trial_list_() { + FieldTrialTest() : trial_list_("client_id") { Time now = Time::NowFromSystemTime(); TimeDelta oneYear = TimeDelta::FromDays(365); Time::Exploded exploded; @@ -224,9 +228,10 @@ TEST_F(FieldTrialTest, Save) { new FieldTrial( "Some name", 10, "Default some name", next_year_, 12, 31); // There is no winner yet, so no textual group name is associated with trial. + // In this case, the trial should not be included. EXPECT_EQ("", trial->group_name_internal()); FieldTrialList::StatesToString(&save_string); - EXPECT_EQ("Some name/Default some name/", save_string); + EXPECT_EQ("", save_string); save_string.clear(); // Create a winning group. @@ -265,10 +270,10 @@ TEST_F(FieldTrialTest, Restore) { TEST_F(FieldTrialTest, BogusRestore) { EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess("MissingSlash")); EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess("MissingGroupName/")); - EXPECT_FALSE( - FieldTrialList::CreateTrialsInChildProcess("MissingFinalSlash/gname")); - EXPECT_FALSE( - FieldTrialList::CreateTrialsInChildProcess("/noname, only group/")); + EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess( + "MissingFinalSlash/gname")); + EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess( + "noname, only group/")); } TEST_F(FieldTrialTest, DuplicateRestore) { @@ -284,7 +289,8 @@ TEST_F(FieldTrialTest, DuplicateRestore) { EXPECT_TRUE(FieldTrialList::CreateTrialsInChildProcess(save_string)); // But it is an error to try to change to a different winner. - EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess("Some name/Loser/")); + EXPECT_FALSE(FieldTrialList::CreateTrialsInChildProcess( + "Some name/Loser/")); } TEST_F(FieldTrialTest, CreateFieldTrial) { @@ -321,4 +327,109 @@ TEST_F(FieldTrialTest, MakeName) { FieldTrial::MakeName("Histogram", "Field Trial")); } +TEST_F(FieldTrialTest, HashClientId) { + double results[] = { + FieldTrial::HashClientId("hi", "1"), + FieldTrial::HashClientId("there", "1"), + }; + ASSERT_NE(results[0], results[1]); + for (size_t i = 0; i < arraysize(results); ++i) { + ASSERT_LE(0.0, results[i]); + ASSERT_GT(1.0, results[i]); + } + + ASSERT_EQ(FieldTrial::HashClientId("yo", "1"), + FieldTrial::HashClientId("yo", "1")); + ASSERT_NE(FieldTrial::HashClientId("yo", "something"), + FieldTrial::HashClientId("yo", "else")); +} + +TEST_F(FieldTrialTest, HashClientIdIsUniform) { + // Choose a random start number but go sequentially from there, so + // that each test tries a different range but we never provide uniformly + // distributed input data. + int current_number = RandInt(0, std::numeric_limits<int>::max()); + + // The expected value of a random distribution is the average over all + // samples as the number of samples approaches infinity. For a uniform + // distribution from [0.0, 1.0) this would be 0.5. + // + // We do kSamplesBetweenChecks at a time and check if the value has converged + // to a narrow interval around 0.5. A non-uniform distribution would likely + // converge at something different, or not converge consistently within this + // range (i.e. the test would start timing out occasionally). + int kSamplesBetweenChecks = 300; + int num_samples = 0; + double total_value = 0.0; + while (true) { + for (int i = 0; i < kSamplesBetweenChecks; ++i) { + total_value += FieldTrial::HashClientId( + IntToString(current_number++), "salt"); + num_samples++; + } + + double average = total_value / num_samples; + double kExpectedMin = 0.48; + double kExpectedMax = 0.52; + + if (num_samples > 1000 && + (average < kExpectedMin || average > kExpectedMax)) { + // Only printed once we have enough samples that it's very unlikely + // things haven't converged. + printf("After %d samples, the average was %f, outside the expected\n" + "range (%f, %f). We will add more samples and check after every\n" + "%d samples. If the average does not converge, something\n" + "is broken. If it does converge, the test will pass.\n", + num_samples, average, + kExpectedMin, kExpectedMax, kSamplesBetweenChecks); + } else { + // Success. + break; + } + } +} + +TEST_F(FieldTrialTest, UseOneTimeRandomization) { + // Simply asserts that two trials using one-time randomization + // that have different names, normally generate different results. + // + // Note that depending on the one-time random initialization, they + // _might_ actually give the same result, but we know that given + // the particular client_id we use for unit tests they won't. + scoped_refptr<FieldTrial> trials[] = { + new FieldTrial("one", 100, "default", next_year_, 1, 1), + new FieldTrial("two", 100, "default", next_year_, 1, 1), + }; + + for (size_t i = 0; i < arraysize(trials); ++i) { + trials[i]->UseOneTimeRandomization(); + + for (int j = 0; j < 100; ++j) { + trials[i]->AppendGroup("", 1); + } + } + + // The trials are most likely to give different results since they have + // different names. + ASSERT_NE(trials[0]->group(), trials[1]->group()); + ASSERT_NE(trials[0]->group_name(), trials[1]->group_name()); +} + +TEST_F(FieldTrialTest, DisableImmediately) { + FieldTrial* trial = + new FieldTrial("trial", 100, "default", next_year_, 12, 31); + trial->Disable(); + ASSERT_EQ("default", trial->group_name()); + ASSERT_EQ(FieldTrial::kDefaultGroupNumber, trial->group()); +} + +TEST_F(FieldTrialTest, DisableAfterInitialization) { + FieldTrial* trial = + new FieldTrial("trial", 100, "default", next_year_, 12, 31); + trial->AppendGroup("non_default", 100); + ASSERT_EQ("non_default", trial->group_name()); + trial->Disable(); + ASSERT_EQ("default", trial->group_name()); +} + } // namespace base diff --git a/base/rand_util.cc b/base/rand_util.cc index fc41ce8..4140e9a 100644 --- a/base/rand_util.cc +++ b/base/rand_util.cc @@ -25,6 +25,10 @@ int RandInt(int min, int max) { } double RandDouble() { + return BitsToOpenEndedUnitInterval(base::RandUint64()); +} + +double BitsToOpenEndedUnitInterval(uint64 bits) { // We try to get maximum precision by masking out as many bits as will fit // in the target type's mantissa, and raising it to an appropriate power to // produce output in the range [0, 1). For IEEE 754 doubles, the mantissa @@ -32,7 +36,7 @@ double RandDouble() { COMPILE_ASSERT(std::numeric_limits<double>::radix == 2, otherwise_use_scalbn); static const int kBits = std::numeric_limits<double>::digits; - uint64 random_bits = base::RandUint64() & ((GG_UINT64_C(1) << kBits) - 1); + uint64 random_bits = bits & ((GG_UINT64_C(1) << kBits) - 1); double result = ldexp(static_cast<double>(random_bits), -1 * kBits); DCHECK_GE(result, 0.0); DCHECK_LT(result, 1.0); diff --git a/base/rand_util.h b/base/rand_util.h index 541fd77..6bfbcb4 100644 --- a/base/rand_util.h +++ b/base/rand_util.h @@ -29,6 +29,10 @@ BASE_API uint64 RandGenerator(uint64 max); // Returns a random double in range [0, 1). Thread-safe. BASE_API double RandDouble(); +// Given input |bits|, convert with maximum precision to a double in +// the range [0, 1). Thread-safe. +BASE_API double BitsToOpenEndedUnitInterval(uint64 bits); + // Fills |output_length| bytes of |output| with cryptographically strong random // data. BASE_API void RandBytes(void* output, size_t output_length); diff --git a/chrome/browser/browser_main.cc b/chrome/browser/browser_main.cc index 53cb319..5fb61be 100644 --- a/chrome/browser/browser_main.cc +++ b/chrome/browser/browser_main.cc @@ -246,16 +246,28 @@ void BrowserMainParts::EarlyInitialization() { } // This will be called after the command-line has been mutated by about:flags -void BrowserMainParts::SetupFieldTrials() { - // Note: make sure to call ConnectionFieldTrial() before - // ProxyConnectionsFieldTrial(). - ConnectionFieldTrial(); - SocketTimeoutFieldTrial(); - ProxyConnectionsFieldTrial(); - prerender::ConfigurePrefetchAndPrerender(parsed_command_line()); - SpdyFieldTrial(); - ConnectBackupJobsFieldTrial(); - SSLFalseStartFieldTrial(); +MetricsService* BrowserMainParts::SetupMetricsAndFieldTrials( + const CommandLine& parsed_command_line, + PrefService* local_state) { + // Must initialize metrics after labs have been converted into switches, + // but before field trials are set up (so that client ID is available for + // one-time randomized field trials). + MetricsService* metrics = InitializeMetrics(parsed_command_line, local_state); + + // Initialize FieldTrialList to support FieldTrials that use one-time + // randomization. The client ID will be empty if the user has not opted + // to send metrics. + field_trial_list_.reset(new base::FieldTrialList(metrics->GetClientId())); + + SetupFieldTrials(metrics->recording_active()); + + // Initialize FieldTrialSynchronizer system. This is a singleton and is used + // for posting tasks via NewRunnableMethod. Its deleted when it goes out of + // scope. Even though NewRunnableMethod does AddRef and Release, the object + // will not be deleted after the Task is executed. + field_trial_synchronizer_ = new FieldTrialSynchronizer(); + + return metrics; } // This is an A/B test for the maximum number of persistent connections per @@ -538,6 +550,62 @@ void BrowserMainParts::InitializeMainThread() { MessageLoop::current())); } +// BrowserMainParts: |SetupMetricsAndFieldTrials()| related -------------------- + +// Initializes the metrics service with the configuration for this process, +// returning the created service (guaranteed non-NULL). +MetricsService* BrowserMainParts::InitializeMetrics( + const CommandLine& parsed_command_line, + const PrefService* local_state) { +#if defined(OS_WIN) + if (parsed_command_line.HasSwitch(switches::kChromeFrame)) + MetricsLog::set_version_extension("-F"); +#elif defined(ARCH_CPU_64_BITS) + MetricsLog::set_version_extension("-64"); +#endif // defined(OS_WIN) + + MetricsService* metrics = g_browser_process->metrics_service(); + + if (parsed_command_line.HasSwitch(switches::kMetricsRecordingOnly) || + parsed_command_line.HasSwitch(switches::kEnableBenchmarking)) { + // If we're testing then we don't care what the user preference is, we turn + // on recording, but not reporting, otherwise tests fail. + metrics->StartRecordingOnly(); + return metrics; + } + + // If the user permits metrics reporting with the checkbox in the + // prefs, we turn on recording. We disable metrics completely for + // non-official builds. +#if defined(GOOGLE_CHROME_BUILD) +#if defined(OS_CHROMEOS) + bool enabled = chromeos::MetricsCrosSettingsProvider::GetMetricsStatus(); +#else + bool enabled = local_state->GetBoolean(prefs::kMetricsReportingEnabled); +#endif // #if defined(OS_CHROMEOS) + if (enabled) { + metrics->Start(); + } +#endif // defined(GOOGLE_CHROME_BUILD) + + return metrics; +} + +void BrowserMainParts::SetupFieldTrials(bool metrics_recording_enabled) { + if (metrics_recording_enabled) + chrome_browser_net_websocket_experiment::WebSocketExperimentRunner::Start(); + + // Note: make sure to call ConnectionFieldTrial() before + // ProxyConnectionsFieldTrial(). + ConnectionFieldTrial(); + SocketTimeoutFieldTrial(); + ProxyConnectionsFieldTrial(); + prerender::ConfigurePrefetchAndPrerender(parsed_command_line()); + SpdyFieldTrial(); + ConnectBackupJobsFieldTrial(); + SSLFalseStartFieldTrial(); +} + // ----------------------------------------------------------------------------- // TODO(viettrungluu): move more/rest of BrowserMain() into above structure @@ -772,45 +840,6 @@ void InitializeBrokerServices(const MainFunctionParams& parameters, #endif } -// Initializes the metrics service with the configuration for this process, -// returning the created service (guaranteed non-NULL). -MetricsService* InitializeMetrics(const CommandLine& parsed_command_line, - const PrefService* local_state) { -#if defined(OS_WIN) - if (parsed_command_line.HasSwitch(switches::kChromeFrame)) - MetricsLog::set_version_extension("-F"); -#elif defined(ARCH_CPU_64_BITS) - MetricsLog::set_version_extension("-64"); -#endif // defined(OS_WIN) - - MetricsService* metrics = g_browser_process->metrics_service(); - - if (parsed_command_line.HasSwitch(switches::kMetricsRecordingOnly) || - parsed_command_line.HasSwitch(switches::kEnableBenchmarking)) { - // If we're testing then we don't care what the user preference is, we turn - // on recording, but not reporting, otherwise tests fail. - metrics->StartRecordingOnly(); - } else { - // If the user permits metrics reporting with the checkbox in the - // prefs, we turn on recording. We disable metrics completely for - // non-official builds. -#if defined(GOOGLE_CHROME_BUILD) -#if defined(OS_CHROMEOS) - bool enabled = chromeos::MetricsCrosSettingsProvider::GetMetricsStatus(); -#else - bool enabled = local_state->GetBoolean(prefs::kMetricsReportingEnabled); -#endif // #if defined(OS_CHROMEOS) - if (enabled) { - metrics->Start(); - chrome_browser_net_websocket_experiment:: - WebSocketExperimentRunner::Start(); - } -#endif - } - - return metrics; -} - // Initializes the profile, possibly doing some user prompting to pick a // fallback profile. Returns the newly created profile, or NULL if startup // should not continue. @@ -1368,16 +1397,10 @@ int BrowserMain(const MainFunctionParams& parameters) { about_flags::ConvertFlagsToSwitches(local_state, CommandLine::ForCurrentProcess()); - // Now the command line has been mutated based on about:flags, we can run some - // field trials - parts->SetupFieldTrials(); - - // Initialize FieldTrialSynchronizer system. This is a singleton and is used - // for posting tasks via NewRunnableMethod. Its deleted when it goes out of - // scope. Even though NewRunnableMethod does AddRef and Release, the object - // will not be deleted after the Task is executed. - scoped_refptr<FieldTrialSynchronizer> field_trial_synchronizer( - new FieldTrialSynchronizer()); + // Now the command line has been mutated based on about:flags, we can + // set up metrics and initialize field trials. + MetricsService* metrics = parts->SetupMetricsAndFieldTrials( + parsed_command_line, local_state); // Now that all preferences have been registered, set the install date // for the uninstall metrics if this is our first run. This only actually @@ -1721,7 +1744,6 @@ int BrowserMain(const MainFunctionParams& parameters) { sdch_manager.set_sdch_fetcher(new SdchDictionaryFetcher); sdch_manager.EnableSdchSupport(sdch_supported_domain); - MetricsService* metrics = InitializeMetrics(parsed_command_line, local_state); InstallJankometer(parsed_command_line); #if defined(OS_WIN) && !defined(GOOGLE_CHROME_BUILD) diff --git a/chrome/browser/browser_main.h b/chrome/browser/browser_main.h index 41e6f95..a867e20 100644 --- a/chrome/browser/browser_main.h +++ b/chrome/browser/browser_main.h @@ -13,10 +13,12 @@ class BrowserThread; class CommandLine; +class FieldTrialSynchronizer; class HighResolutionTimerManager; struct MainFunctionParams; class MessageLoop; class MetricsService; +class PrefService; namespace net { class NetworkChangeNotifier; @@ -80,7 +82,12 @@ class BrowserMainParts { void EarlyInitialization(); void MainMessageLoopStart(); - void SetupFieldTrials(); + // Constructs metrics service and does related initialization, including + // creation of field trials. Call only after labs have been converted to + // switches. + MetricsService* SetupMetricsAndFieldTrials( + const CommandLine& parsed_command_line, + PrefService* local_state); protected: explicit BrowserMainParts(const MainFunctionParams& parameters); @@ -132,6 +139,15 @@ class BrowserMainParts { void InitializeMainThread(); + // Methods for |SetupMetricsAndFieldTrials()| -------------------------------- + + static MetricsService* InitializeMetrics( + const CommandLine& parsed_command_line, + const PrefService* local_state); + + // Add an invocation of your field trial init function to this method. + void SetupFieldTrials(bool metrics_recording_enabled); + // Members initialized on construction --------------------------------------- const MainFunctionParams& parameters_; @@ -144,8 +160,9 @@ class BrowserMainParts { tracked_objects::AutoTracking tracking_objects_; #endif - // Statistical testing infrastructure for the entire browser. - base::FieldTrialList field_trial_; + // Statistical testing infrastructure for the entire browser. NULL until + // SetupMetricsAndFieldTrials is called. + scoped_ptr<base::FieldTrialList> field_trial_list_; // Members initialized in |MainMessageLoopStart()| --------------------------- scoped_ptr<MessageLoop> main_message_loop_; @@ -154,6 +171,9 @@ class BrowserMainParts { scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_; scoped_ptr<BrowserThread> main_thread_; + // Initialized in SetupMetricsAndFieldTrials. + scoped_refptr<FieldTrialSynchronizer> field_trial_synchronizer_; + DISALLOW_COPY_AND_ASSIGN(BrowserMainParts); }; diff --git a/chrome/browser/metrics/metrics_service.cc b/chrome/browser/metrics/metrics_service.cc index bc4e094..ce77ae5 100644 --- a/chrome/browser/metrics/metrics_service.cc +++ b/chrome/browser/metrics/metrics_service.cc @@ -471,6 +471,10 @@ void MetricsService::Stop() { SetRecording(false); } +std::string MetricsService::GetClientId() { + return client_id_; +} + void MetricsService::SetRecording(bool enabled) { DCHECK(IsSingleThreaded()); diff --git a/chrome/browser/metrics/metrics_service.h b/chrome/browser/metrics/metrics_service.h index 491a375..9809934 100644 --- a/chrome/browser/metrics/metrics_service.h +++ b/chrome/browser/metrics/metrics_service.h @@ -82,6 +82,10 @@ class MetricsService : public NotificationObserver, void StartRecordingOnly(); void Stop(); + // Returns the client ID for this client, or the empty string if metrics + // recording is not currently running. + std::string GetClientId(); + // At startup, prefs needs to be called with a list of all the pref names and // types we'll be using. static void RegisterPrefs(PrefService* local_state); diff --git a/chrome/renderer/page_load_histograms.cc b/chrome/renderer/page_load_histograms.cc index 3ae1498..6bd2c85 100644 --- a/chrome/renderer/page_load_histograms.cc +++ b/chrome/renderer/page_load_histograms.cc @@ -270,8 +270,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { } // 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"), @@ -307,8 +307,7 @@ void PageLoadHistograms::Dump(WebFrame* frame) { // 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( @@ -338,9 +337,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { } // 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"), @@ -378,9 +376,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { // 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"), @@ -412,9 +409,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { } // 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"), @@ -446,10 +442,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { } // 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"), @@ -482,8 +476,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { // 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"), @@ -520,8 +514,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { } // 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 @@ -531,9 +525,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { } // 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"), @@ -591,8 +584,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { // 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( @@ -749,8 +742,8 @@ void PageLoadHistograms::Dump(WebFrame* frame) { } } - 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) { diff --git a/chrome/renderer/prerender/prerender_helper.cc b/chrome/renderer/prerender/prerender_helper.cc index 09efc71..47b1d70 100644 --- a/chrome/renderer/prerender/prerender_helper.cc +++ b/chrome/renderer/prerender/prerender_helper.cc @@ -45,8 +45,7 @@ void PrerenderHelper::RecordHistograms( const base::Time& finish_all_loads, const base::TimeDelta& begin_to_finish_all_loads) { static bool use_prerender_histogram = - base::FieldTrialList::Find("Prefetch") && - !base::FieldTrialList::Find("Prefetch")->group_name().empty(); + base::FieldTrialList::TrialExists("Prefetch"); if (!use_prerender_histogram) return; diff --git a/content/renderer/renderer_main.cc b/content/renderer/renderer_main.cc index e5e6984..36c73ba 100644 --- a/content/renderer/renderer_main.cc +++ b/content/renderer/renderer_main.cc @@ -191,8 +191,10 @@ int RendererMain(const MainFunctionParams& parameters) { statistics.reset(new base::StatisticsRecorder()); } - // Initialize statistical testing infrastructure. - base::FieldTrialList field_trial; + // Initialize statistical testing infrastructure. We set client_id to the + // empty string to disallow the renderer process from creating its own + // one-time randomized trials; they should be created in the browser process. + base::FieldTrialList field_trial(EmptyString()); // Ensure any field trials in browser are reflected into renderer. if (parsed_command_line.HasSwitch(switches::kForceFieldTestNameAndValue)) { std::string persistent = parsed_command_line.GetSwitchValueASCII( diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc index 8b33229..8c9d17f 100644 --- a/net/base/host_resolver_impl.cc +++ b/net/base/host_resolver_impl.cc @@ -554,9 +554,8 @@ class HostResolverImpl::Job UMA_HISTOGRAM_ENUMERATION("DNS.ResolveCategory", category, RESOLVE_MAX); - static bool show_speculative_experiment_histograms = - base::FieldTrialList::Find("DnsImpact") && - !base::FieldTrialList::Find("DnsImpact")->group_name().empty(); + static const bool show_speculative_experiment_histograms = + base::FieldTrialList::TrialExists("DnsImpact"); if (show_speculative_experiment_histograms) { UMA_HISTOGRAM_ENUMERATION( base::FieldTrial::MakeName("DNS.ResolveCategory", "DnsImpact"), @@ -566,9 +565,8 @@ class HostResolverImpl::Job "DnsImpact"), duration); } } - static bool show_parallelism_experiment_histograms = - base::FieldTrialList::Find("DnsParallelism") && - !base::FieldTrialList::Find("DnsParallelism")->group_name().empty(); + static const bool show_parallelism_experiment_histograms = + base::FieldTrialList::TrialExists("DnsParallelism"); if (show_parallelism_experiment_histograms) { UMA_HISTOGRAM_ENUMERATION( base::FieldTrial::MakeName("DNS.ResolveCategory", "DnsParallelism"), diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc index ec7561b..c8b2b33 100644 --- a/net/http/http_cache_transaction.cc +++ b/net/http/http_cache_transaction.cc @@ -870,8 +870,7 @@ int HttpCache::Transaction::DoAddToEntryComplete(int result) { base::TimeTicks::Now() - entry_lock_waiting_since_; UMA_HISTOGRAM_TIMES("HttpCache.EntryLockWait", entry_lock_wait); static const bool prefetching_fieldtrial = - base::FieldTrialList::Find("Prefetch") && - !base::FieldTrialList::Find("Prefetch")->group_name().empty(); + base::FieldTrialList::TrialExists("Prefetch"); if (prefetching_fieldtrial) { UMA_HISTOGRAM_TIMES( base::FieldTrial::MakeName("HttpCache.EntryLockWait", "Prefetch"), diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc index 5cd2f92..f298679 100644 --- a/net/http/http_network_transaction.cc +++ b/net/http/http_network_transaction.cc @@ -1010,9 +1010,8 @@ void HttpNetworkTransaction::LogTransactionConnectedMetrics() { base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10), 100); - static bool use_conn_impact_histogram( - base::FieldTrialList::Find("ConnCountImpact") && - !base::FieldTrialList::Find("ConnCountImpact")->group_name().empty()); + static const bool use_conn_impact_histogram = + base::FieldTrialList::TrialExists("ConnCountImpact"); if (use_conn_impact_histogram) { UMA_HISTOGRAM_CLIPPED_TIMES( base::FieldTrial::MakeName("Net.Transaction_Connected_New", @@ -1023,8 +1022,8 @@ void HttpNetworkTransaction::LogTransactionConnectedMetrics() { } } - 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 && response_.was_npn_negotiated) { UMA_HISTOGRAM_CLIPPED_TIMES( base::FieldTrial::MakeName("Net.Transaction_Connected_Under_10", diff --git a/net/socket/client_socket_pool_histograms.cc b/net/socket/client_socket_pool_histograms.cc index 202112b..5c3bddb 100644 --- a/net/socket/client_socket_pool_histograms.cc +++ b/net/socket/client_socket_pool_histograms.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// 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. @@ -58,10 +58,8 @@ void ClientSocketPoolHistograms::AddSocketType(int type) const { void ClientSocketPoolHistograms::AddRequestTime(base::TimeDelta time) const { request_time_->AddTime(time); - static bool proxy_connection_impact_trial_exists( - base::FieldTrialList::Find("ProxyConnectionImpact") && - !base::FieldTrialList::Find("ProxyConnectionImpact")-> - group_name().empty()); + static const bool proxy_connection_impact_trial_exists = + base::FieldTrialList::TrialExists("ProxyConnectionImpact"); if (proxy_connection_impact_trial_exists && is_http_proxy_connection_) { UMA_HISTOGRAM_CUSTOM_TIMES( base::FieldTrial::MakeName("Net.HttpProxySocketRequestTime", diff --git a/net/socket/ssl_client_socket_pool.cc b/net/socket/ssl_client_socket_pool.cc index 75d36cb..dee34cd 100644 --- a/net/socket/ssl_client_socket_pool.cc +++ b/net/socket/ssl_client_socket_pool.cc @@ -348,9 +348,8 @@ int SSLConnectJob::DoSSLConnectComplete(int result) { 100); } - 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) { UMA_HISTOGRAM_CUSTOM_TIMES(base::FieldTrial::MakeName( "Net.SSL_Connection_Latency", diff --git a/net/socket/stream_socket.cc b/net/socket/stream_socket.cc index 37482b4..3ef24c0 100644 --- a/net/socket/stream_socket.cc +++ b/net/socket/stream_socket.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// 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. @@ -134,8 +134,7 @@ void StreamSocket::UseHistory::EmitPreconnectionHistograms() const { UMA_HISTOGRAM_ENUMERATION("Net.PreconnectUtilization2", result, 9); static const bool connect_backup_jobs_fieldtrial = - base::FieldTrialList::Find("ConnnectBackupJobs") && - !base::FieldTrialList::Find("ConnnectBackupJobs")->group_name().empty(); + base::FieldTrialList::TrialExists("ConnnectBackupJobs"); if (connect_backup_jobs_fieldtrial) { UMA_HISTOGRAM_ENUMERATION( base::FieldTrial::MakeName("Net.PreconnectUtilization2", diff --git a/net/url_request/url_request_http_job.cc b/net/url_request/url_request_http_job.cc index 95ea53c..8504260 100644 --- a/net/url_request/url_request_http_job.cc +++ b/net/url_request/url_request_http_job.cc @@ -1127,8 +1127,7 @@ void URLRequestHttpJob::RecordTimer() { request_creation_time_ = base::Time(); static const bool use_prefetch_histogram = - base::FieldTrialList::Find("Prefetch") && - !base::FieldTrialList::Find("Prefetch")->group_name().empty(); + base::FieldTrialList::TrialExists("Prefetch"); UMA_HISTOGRAM_MEDIUM_TIMES("Net.HttpTimeToFirstByte", to_start); if (use_prefetch_histogram) { |