Actually update FieldTrialEntry's activated field

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"
@@ skipping 291 matching lines @@
     : trial_name_(trial_name),
       divisor_(total_probability),
       default_group_name_(default_group_name),
       random_(GetGroupBoundaryValue(total_probability, entropy_value)),
       accumulated_group_probability_(0),
       next_group_number_(kDefaultGroupNumber + 1),
       group_(kNotFinalized),
       enable_field_trial_(true),
       forced_(false),
       group_reported_(false),
-      trial_registered_(false) {
+      trial_registered_(false),
+      ref_(SharedPersistentMemoryAllocator::kReferenceNull) {
   DCHECK_GT(total_probability, 0);
   DCHECK(!trial_name_.empty());
   DCHECK(!default_group_name_.empty());
 }
 
 FieldTrial::~FieldTrial() {}
 
 void FieldTrial::SetTrialRegistered() {
   DCHECK_EQ(kNotFinalized, group_);
   DCHECK(!trial_registered_);
@@ skipping 10 matching lines @@
 }
 
 void FieldTrial::FinalizeGroupChoice() {
   if (group_ != kNotFinalized)
     return;
   accumulated_group_probability_ = divisor_;
   // Here it's OK to use |kDefaultGroupNumber| since we can't be forced and not
   // finalized.
   DCHECK(!forced_);
   SetGroupChoice(default_group_name_, kDefaultGroupNumber);
+
+  // Add the field trial to shared memory.
+  if (kUseSharedMemoryForFieldTrials)
+    FieldTrialList::OnGroupFinalized(this);
 }
 
 bool FieldTrial::GetActiveGroup(ActiveGroup* active_group) const {
   if (!group_reported_ || !enable_field_trial_)
     return false;
   DCHECK_NE(group_, kNotFinalized);
   active_group->trial_name = trial_name_;
   active_group->group_name = group_name_;
   return true;
 }
@@ skipping 313 matching lines @@
     return;
   if (kUseSharedMemoryForFieldTrials) {
     InstantiateFieldTrialAllocatorIfNeeded();
     if (global_->readonly_allocator_handle_)
       handles->push_back(global_->readonly_allocator_handle_);
   }
 }
 #endif
 
 // static
-void FieldTrialList::CreateTrialsFromSharedMemory(
-    std::unique_ptr<SharedMemory> shm) {
-  const SharedPersistentMemoryAllocator shalloc(std::move(shm), 0,
-                                                kAllocatorName, true);
-  PersistentMemoryAllocator::Iterator iter(&shalloc);
-
-  SharedPersistentMemoryAllocator::Reference ref;
-  while ((ref = iter.GetNextOfType(kFieldTrialType)) !=
-         SharedPersistentMemoryAllocator::kReferenceNull) {
-    const FieldTrialEntry* entry =
-        shalloc.GetAsObject<const FieldTrialEntry>(ref, kFieldTrialType);
-    FieldTrial* trial =
-        CreateFieldTrial(entry->GetTrialName(), entry->GetGroupName());
-
-    if (entry->activated) {
-      // Call |group()| to mark the trial as "used" and notify observers, if
-      // any. This is useful to ensure that field trials created in child
-      // processes are properly reported in crash reports.
-      trial->group();
-    }
-  }
-}
-
-// static
 void FieldTrialList::CopyFieldTrialStateToFlags(
     const char* field_trial_handle_switch,
     CommandLine* cmd_line) {
 #if defined(OS_WIN)
   // Use shared memory to pass the state if the feature is enabled, otherwise
   // fallback to passing it via the command line as a string.
   if (kUseSharedMemoryForFieldTrials) {
     InstantiateFieldTrialAllocatorIfNeeded();
     // If the readonly handle didn't get duplicated properly, then fallback to
     // original behavior.
@@ skipping 55 matching lines @@
 }
 
 // static
 void FieldTrialList::RemoveObserver(Observer* observer) {
   if (!global_)
     return;
   global_->observer_list_->RemoveObserver(observer);
 }
 
 // static
+void FieldTrialList::OnGroupFinalized(FieldTrial* field_trial) {
+  if (!global_)
+    return;
+  AutoLock auto_lock(global_->lock_);
+  AddToAllocatorWhileLocked(field_trial);
+}
+
+// static
 void FieldTrialList::NotifyFieldTrialGroupSelection(FieldTrial* field_trial) {
   if (!global_)
     return;
 
   {
     AutoLock auto_lock(global_->lock_);
     if (field_trial->group_reported_)
       return;
     field_trial->group_reported_ = true;
 
     if (!field_trial->enable_field_trial_)
       return;
 
-    if (kUseSharedMemoryForFieldTrials) {
-      field_trial->AddToAllocatorWhileLocked(
-          global_->field_trial_allocator_.get());
-    }
+    if (kUseSharedMemoryForFieldTrials)
+      ActivateFieldTrialEntryWhileLocked(field_trial);
   }
 
   global_->observer_list_->Notify(
       FROM_HERE, &FieldTrialList::Observer::OnFieldTrialGroupFinalized,
       field_trial->trial_name(), field_trial->group_name_internal());
 }
 
+// static
+size_t FieldTrialList::GetFieldTrialCount() {
+  if (!global_)
+    return 0;
+  AutoLock auto_lock(global_->lock_);
+  return global_->registered_.size();
+}
+
+// static
+void FieldTrialList::CreateTrialsFromSharedMemory(
+    std::unique_ptr<SharedMemory> shm) {
+  const SharedPersistentMemoryAllocator shalloc(std::move(shm), 0,
+                                                kAllocatorName, true);
+  PersistentMemoryAllocator::Iterator iter(&shalloc);
+
+  SharedPersistentMemoryAllocator::Reference ref;
+  while ((ref = iter.GetNextOfType(kFieldTrialType)) !=
+         SharedPersistentMemoryAllocator::kReferenceNull) {
+    const FieldTrialEntry* entry =
+        shalloc.GetAsObject<const FieldTrialEntry>(ref, kFieldTrialType);
+    FieldTrial* trial =
+        CreateFieldTrial(entry->GetTrialName(), entry->GetGroupName());
+
+    if (entry->activated) {
+      // Call |group()| to mark the trial as "used" and notify observers, if
+      // any. This is useful to ensure that field trials created in child
+      // processes are properly reported in crash reports.
+      trial->group();
+    }
+  }
+}
+
 #if !defined(OS_NACL)
 // static
 void FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded() {
+  if (!global_)
+    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_) {
-    registered.second->AddToAllocatorWhileLocked(
-        global_->field_trial_allocator_.get());
+    AddToAllocatorWhileLocked(registered.second);
   }
 
 #if defined(OS_WIN)
-  // Set |readonly_allocator_handle_| so we can pass it to be inherited and via
-  // the command line.
+  // Set |readonly_allocator_handle_| so we can pass it to be inherited and
+  // via the command line.
   global_->readonly_allocator_handle_ =
       CreateReadOnlyHandle(global_->field_trial_allocator_.get());
 #endif
 }
 #endif
 
-void FieldTrial::AddToAllocatorWhileLocked(
-    SharedPersistentMemoryAllocator* allocator) {
+// static
+void FieldTrialList::AddToAllocatorWhileLocked(FieldTrial* field_trial) {
+  SharedPersistentMemoryAllocator* allocator =
+      global_->field_trial_allocator_.get();
+
   // Don't do anything if the allocator hasn't been instantiated yet.
   if (allocator == nullptr)
     return;
 
-  State trial_state;
-  if (!GetState(&trial_state))
+  // Or if we've already added it.
+  if (field_trial->ref_ != SharedPersistentMemoryAllocator::kReferenceNull)
+    return;
+
+  FieldTrial::State trial_state;
+  if (!field_trial->GetState(&trial_state))
     return;
 
   size_t trial_name_size = trial_state.trial_name.size() + 1;
   size_t group_name_size = trial_state.group_name.size() + 1;
   size_t size = sizeof(FieldTrialEntry) + trial_name_size + group_name_size;
 
   // Allocate just enough memory to fit the FieldTrialEntry struct, trial name,
   // and group name.
   SharedPersistentMemoryAllocator::Reference ref =
       allocator->Allocate(size, kFieldTrialType);
@@ skipping 12 matching lines @@
   char* trial_name = reinterpret_cast<char*>(entry) + trial_name_offset;
   char* group_name = reinterpret_cast<char*>(entry) + group_name_offset;
   memcpy(trial_name, trial_state.trial_name.data(), trial_name_size);
   memcpy(group_name, trial_state.group_name.data(), group_name_size);
 
   // Null terminate the strings.
   trial_name[trial_state.trial_name.size()] = '\0';
   group_name[trial_state.group_name.size()] = '\0';
 
   allocator->MakeIterable(ref);
+  field_trial->ref_ = ref;
 }
 
 // static
-size_t FieldTrialList::GetFieldTrialCount() {
-  if (!global_)
-    return 0;
-  AutoLock auto_lock(global_->lock_);
-  return global_->registered_.size();
+void FieldTrialList::ActivateFieldTrialEntryWhileLocked(
+    FieldTrial* field_trial) {
+  SharedPersistentMemoryAllocator* allocator =
+      global_->field_trial_allocator_.get();
+  SharedPersistentMemoryAllocator::Reference ref = field_trial->ref_;
+  if (ref == SharedPersistentMemoryAllocator::kReferenceNull) {
+    // It's fine to do this even if the allocator hasn't been instantiated
+    // yet -- it'll just return early.
+    AddToAllocatorWhileLocked(field_trial);
+  } else {
+    // It's also okay to do this even though the callee doesn't have a lock --
+    // the only thing that happens on a stale read here is a slight performance
+    // hit from the child re-synchronizing activation state.
+    FieldTrialEntry* entry =
+        allocator->GetAsObject<FieldTrialEntry>(ref, kFieldTrialType);
+    entry->activated = true;
+  }
 }
 
 // static
 const FieldTrial::EntropyProvider*
     FieldTrialList::GetEntropyProviderForOneTimeRandomization() {
   if (!global_) {
     used_without_global_ = true;
     return NULL;
   }
 
@@ skipping 14 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