Create FieldTrialAllocator.Size histogram

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 <utility>
 
 #include "base/base_switches.h"
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/process/memory.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 {
@@ skipping 22 matching lines @@
 
 // We create one FieldTrialEntry struct per field trial in shared memory (via
 // field_trial_allocator_). It contains whether or not it's activated, and the
 // offset from the start of the allocated memory to the group name. We don't
 // need the offset into the trial name because that's always a fixed position
 // from the start of the struct. Two strings will be appended to the end of this
 // structure in allocated memory, so the result will look like this:
 // ---------------------------------
 // | fte | trial_name | group_name |
 // ---------------------------------
-// TODO(lawrencewu): Actually update the activated flag.
 struct FieldTrialEntry {
   bool activated;
   uint32_t group_name_offset;
 
   const char* GetTrialName() const {
     const char* src =
         reinterpret_cast<char*>(const_cast<FieldTrialEntry*>(this));
     return src + sizeof(FieldTrialEntry);
   }
 
@@ skipping 630 matching lines @@
     // command-line flag. The child process will do the reverse conversions to
     // retrieve the handle. See http://stackoverflow.com/a/153077
     auto uintptr_handle =
         reinterpret_cast<uintptr_t>(global_->readonly_allocator_handle_);
     size_t field_trial_length =
         global_->field_trial_allocator_->shared_memory()->mapped_size();
     std::string field_trial_handle = std::to_string(uintptr_handle) + "," +
                                      std::to_string(field_trial_length);
 
     cmd_line->AppendSwitchASCII(field_trial_handle_switch, field_trial_handle);
+    UMA_HISTOGRAM_COUNTS_10000("UMA.FieldTrialAllocator.Size",
+                               field_trial_length);
     return;
   }
 #endif
 
   AddForceFieldTrialsFlag(cmd_line);
 }
 
 // static
 FieldTrial* FieldTrialList::CreateFieldTrial(
     const std::string& name,
@@ skipping 104 matching lines @@
     return;
   AutoLock auto_lock(global_->lock_);
   // Create the allocator if not already created and add all existing trials.
   if (global_->field_trial_allocator_ != nullptr)
     return;
 
   std::unique_ptr<SharedMemory> shm(new SharedMemory());
   if (!shm->CreateAndMapAnonymous(kFieldTrialAllocationSize))
     TerminateBecauseOutOfMemory(kFieldTrialAllocationSize);
 
-  // TODO(lawrencewu): call UpdateTrackingHistograms() when all field trials
-  // have been registered (perhaps in the destructor?)
   global_->field_trial_allocator_.reset(new SharedPersistentMemoryAllocator(
       std::move(shm), 0, kAllocatorName, false));
   global_->field_trial_allocator_->CreateTrackingHistograms(kAllocatorName);
 
   // Add all existing field trials.
   for (const auto& registered : global_->registered_) {
     AddToAllocatorWhileLocked(registered.second);
   }
 
 #if defined(OS_WIN)
@@ skipping 100 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