Store ref in field trial in child processes

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 805 matching lines @@
 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 mem_iter(&shalloc);
+  global_->field_trial_allocator_.reset(new SharedPersistentMemoryAllocator(
+      std::move(shm), 0, kAllocatorName, true));
+  SharedPersistentMemoryAllocator* shalloc =
+      global_->field_trial_allocator_.get();
+  PersistentMemoryAllocator::Iterator mem_iter(shalloc);
 
   SharedPersistentMemoryAllocator::Reference ref;
   while ((ref = mem_iter.GetNextOfType(kFieldTrialType)) !=
          SharedPersistentMemoryAllocator::kReferenceNull) {
     const FieldTrialEntry* entry =
-        shalloc.GetAsObject<const FieldTrialEntry>(ref, kFieldTrialType);
+        shalloc->GetAsObject<const FieldTrialEntry>(ref, kFieldTrialType);
 
     StringPiece trial_name;
     StringPiece group_name;
     if (!entry->GetTrialAndGroupName(&trial_name, &group_name)) {
       NOTREACHED();
       continue;
     }
 
     // TODO(lawrencewu): Convert the API for CreateFieldTrial to take
     // StringPieces.
     FieldTrial* trial =
         CreateFieldTrial(trial_name.as_string(), group_name.as_string());
 
+    trial->ref_ = ref;
     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)
@@ skipping 30 matching lines @@
 
 // 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;
 
+  // Or if the allocator is read only, which means we are in a child process and
+  // shouldn't be writing to it.
+  if (allocator->IsReadonly())
+    return;
+
   // 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;
 
   Pickle pickle;
   pickle.WriteString(trial_state.trial_name);
@@ skipping 17 matching lines @@
 
   allocator->MakeIterable(ref);
   field_trial->ref_ = ref;
 }
 
 // static
 void FieldTrialList::ActivateFieldTrialEntryWhileLocked(
     FieldTrial* field_trial) {
   SharedPersistentMemoryAllocator* allocator =
       global_->field_trial_allocator_.get();
+
+  // Check if we're in the child process and return early if so.
+  if (allocator && allocator->IsReadonly())
+    return;
+
   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 =
@@ skipping 27 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