Store and retrieve features from shared memory

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 48 matching lines @@
 // This also doesn't allocate all 128 KiB at once -- the pages only get mapped
 // to physical memory when they are touched. If the size of the allocated field
 // trials does get larger than 128 KiB, then we will drop some field trials in
 // child processes, leading to an inconsistent view between browser and child
 // processes and possibly causing crashes (see crbug.com/661617).
 #if !defined(OS_NACL)
 const size_t kFieldTrialAllocationSize = 128 << 10;  // 128 KiB
 #endif
 
 // We create one FieldTrialEntry per field trial in shared memory, via
-// AddToAllocatorWhileLocked. The FieldTrialEntry is followed by a base::Pickle
-// object that we unpickle and read from. Any changes to this structure requires
-// a bump in kFieldTrialType id defined above.
+// AddTrialToAllocatorWhileLocked. The FieldTrialEntry is followed by a
+// base::Pickle object that we unpickle and read from. Any changes to this
+// structure requires a bump in kFieldTrialType id defined above.
 struct FieldTrialEntry {
   // Expected size for 32/64-bit check.
   static constexpr size_t kExpectedInstanceSize = 8;
 
   // Whether or not this field trial is activated. This is really just a boolean
   // but marked as a uint32_t for portability reasons.
   uint32_t activated;
 
   // Size of the pickled structure, NOT the total size of this entry.
   uint32_t size;
@@ skipping 650 matching lines @@
   if (CreateTrialsFromDescriptor(fd_key))
     return;
 #endif
 
   if (cmd_line.HasSwitch(switches::kForceFieldTrials)) {
     bool result = FieldTrialList::CreateTrialsFromString(
         cmd_line.GetSwitchValueASCII(switches::kForceFieldTrials),
         std::set<std::string>());
     DCHECK(result);
   }
+
+  // TODO(lawrencewu): rename CreateTrialsFromCommandLine to
+  // CreateTrialsAndFeaturesFromCommandLine, cause that's what we're doing.
+  FeatureList::GetInstance()->InitializeFromSharedMemory(
+      global_->field_trial_allocator_.get());
 }
 
 #if defined(POSIX_WITH_ZYGOTE)
 // static
 bool FieldTrialList::CreateTrialsFromDescriptor(int fd_key) {
   if (!kUseSharedMemoryForFieldTrials)
     return false;
 
   if (fd_key == -1)
     return false;
@@ skipping 120 matching lines @@
   if (!global_)
     return;
   global_->observer_list_->RemoveObserver(observer);
 }
 
 // static
 void FieldTrialList::OnGroupFinalized(bool is_locked, FieldTrial* field_trial) {
   if (!global_)
     return;
   if (is_locked) {
-    AddToAllocatorWhileLocked(field_trial);
+    AddTrialToAllocatorWhileLocked(field_trial);
   } else {
     AutoLock auto_lock(global_->lock_);
-    AddToAllocatorWhileLocked(field_trial);
+    AddTrialToAllocatorWhileLocked(field_trial);
   }
 }
 
 // static
 void FieldTrialList::NotifyFieldTrialGroupSelection(FieldTrial* field_trial) {
   if (!global_)
     return;
 
   {
     AutoLock auto_lock(global_->lock_);
@@ skipping 101 matching lines @@
 
   if (!shm->Map(kFieldTrialAllocationSize))
     TerminateBecauseOutOfMemory(kFieldTrialAllocationSize);
 
   global_->field_trial_allocator_.reset(
       new FieldTrialAllocator(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);
+    AddTrialToAllocatorWhileLocked(registered.second);
   }
 
+  // Add all existing features.
+  FeatureList::GetInstance()->AddFeaturesToAllocator(
+      global_->field_trial_allocator_.get());
+
 #if defined(OS_WIN) || defined(POSIX_WITH_ZYGOTE)
   // 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
 
 // static
-void FieldTrialList::AddToAllocatorWhileLocked(FieldTrial* field_trial) {
+void FieldTrialList::AddTrialToAllocatorWhileLocked(FieldTrial* field_trial) {
   FieldTrialAllocator* 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;
@@ skipping 37 matching lines @@
   FieldTrialAllocator* allocator = global_->field_trial_allocator_.get();
 
   // Check if we're in the child process and return early if so.
   if (allocator && allocator->IsReadonly())
     return;
 
   FieldTrial::FieldTrialRef ref = field_trial->ref_;
   if (ref == FieldTrialAllocator::kReferenceNull) {
     // It's fine to do this even if the allocator hasn't been instantiated
     // yet -- it'll just return early.
-    AddToAllocatorWhileLocked(field_trial);
+    AddTrialToAllocatorWhileLocked(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;
   }
 }
 
@@ skipping 22 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