Store field trial parameters in 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 33 matching lines @@
 const char kAllocatorName[] = "FieldTrialAllocator";
 const uint32_t kFieldTrialType = 0xABA17E13 + 1;  // SHA1(FieldTrialEntry) v1
 #if !defined(OS_NACL)
 const size_t kFieldTrialAllocationSize = 4 << 10;  // 4 KiB = one page
 #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.
 struct FieldTrialEntry {
+  // Whether or not this field trial is activated.
   bool activated;
 
   // Size of the pickled structure, NOT the total size of this entry.
   uint32_t size;
 
+  // Returns an iterator over the data used for getting names and params.
+  PickleIterator GetPickleIterator() const {
+    char* src = reinterpret_cast<char*>(const_cast<FieldTrialEntry*>(this)) +
+                sizeof(FieldTrialEntry);
+
+    Pickle pickle(src, size);
+    return PickleIterator(pickle);
+  }
+
+  // Takes the iterator and writes out the first two items into |trial_name| and
+  // |group_name|.
+  bool ReadStringPair(PickleIterator iter,
+                      StringPiece* trial_name,
+                      StringPiece* group_name) const {
+    if (!iter.ReadStringPiece(trial_name))
+      return false;
+    if (!iter.ReadStringPiece(group_name))
+      return false;
+    return true;
+  }
+
   // Calling this is only valid when the entry is initialized. That is, it
   // resides in shared memory and has a pickle containing the trial name and
   // group name following it.
   bool GetTrialAndGroupName(StringPiece* trial_name,
                             StringPiece* group_name) const {
-    char* src = reinterpret_cast<char*>(const_cast<FieldTrialEntry*>(this)) +
-                sizeof(FieldTrialEntry);
+    PickleIterator iter = GetPickleIterator();
+    return ReadStringPair(iter, trial_name, group_name);
+  }
 
-    Pickle pickle(src, size);
-    PickleIterator pickle_iter(pickle);
+  bool GetParams(FieldTrialParamAssociator::FieldTrialParams* params) const {
+    PickleIterator iter = GetPickleIterator();
+    StringPiece tmp;
+    if (!ReadStringPair(iter, &tmp, &tmp))
+      return false;
 
-    if (!pickle_iter.ReadStringPiece(trial_name))
-      return false;
-    if (!pickle_iter.ReadStringPiece(group_name))
-      return false;
-    return true;
+    while (true) {
+      StringPiece key;
+      StringPiece value;
+      if (!iter.ReadStringPiece(&key))
+        return true;  // No more params to read.
+      if (!iter.ReadStringPiece(&value))
+        return false;
+      (*params)[key.as_string()] = value.as_string();
+    }
+
+    NOTREACHED() << "Hit field trial param limit";
+    return false;
   }
 };
 
 // Created a time value based on |year|, |month| and |day_of_month| parameters.
 Time CreateTimeFromParams(int year, int month, int day_of_month) {
   DCHECK_GT(year, 1970);
   DCHECK_GT(month, 0);
   DCHECK_LT(month, 13);
   DCHECK_GT(day_of_month, 0);
   DCHECK_LT(day_of_month, 32);
@@ skipping 89 matching lines @@
   HANDLE src = allocator->shared_memory()->handle().GetHandle();
   ProcessHandle process = GetCurrentProcess();
   DWORD access = SECTION_MAP_READ | SECTION_QUERY;
   HANDLE dst;
   if (!::DuplicateHandle(process, src, process, &dst, access, true, 0))
     return nullptr;
   return dst;
 }
 #endif
 
+bool PickleFieldTrialState(const FieldTrial::State& trial_state,
+                           Pickle* pickle) {
+  pickle->WriteString(trial_state.trial_name);
+  pickle->WriteString(trial_state.group_name);
+
+  std::map<std::string, std::string> params;
+  if (!FieldTrialParamAssociator::GetInstance()
+           ->GetFieldTrialParamsWithGroupName(
+               trial_state.trial_name.as_string(),
+               trial_state.group_name.as_string(), &params)) {
+    return false;
+  }
+
+  for (const auto& param : params) {
+    pickle->WriteString(StringPiece(param.first));
+    pickle->WriteString(StringPiece(param.second));
+  }
+  return true;
+}
+
 }  // namespace
 
 // statics
 const int FieldTrial::kNotFinalized = -1;
 const int FieldTrial::kDefaultGroupNumber = 0;
 bool FieldTrial::enable_benchmarking_ = false;
 
 int FieldTrialList::kNoExpirationYear = 0;
 
 //------------------------------------------------------------------------------
@@ skipping 326 matching lines @@
 
 // static
 std::string FieldTrialList::FindFullName(const std::string& trial_name) {
   FieldTrial* field_trial = Find(trial_name);
   if (field_trial)
     return field_trial->group_name();
   return std::string();
 }
 
 // static
+bool FieldTrialList::FindParams(
+    const std::string& trial_name,
+    FieldTrialParamAssociator::FieldTrialParams* params) {
+  // Check that the allocator exists (it may not exist on Linux or macOS). This
+  // shouldn't ever happen on Windows, as child processes should get an
+  // allocator during initialization, and browser processes won't hit this
+  // function since it has the mapping in FieldTrialParamAssociator.
+  SharedPersistentMemoryAllocator* allocator =
+      global_->field_trial_allocator_.get();
+  if (allocator == nullptr)
+    return false;
+
+  // Get the field trial's corresponding reference in shared memory. This
+  // shouldn't happen for on Windows the same reasons above.
+  FieldTrial* field_trial = Find(trial_name);
+  if (field_trial->ref_ == SharedPersistentMemoryAllocator::kReferenceNull)
+    return false;
+
+  FieldTrialEntry* entry = allocator->GetAsObject<FieldTrialEntry>(
+      field_trial->ref_, kFieldTrialType);
+  return entry->GetParams(params);
+}
+
+// static
 bool FieldTrialList::TrialExists(const std::string& trial_name) {
   return Find(trial_name) != NULL;
 }
 
 // static
 bool FieldTrialList::IsTrialActive(const std::string& trial_name) {
   FieldTrial* field_trial = Find(trial_name);
   FieldTrial::ActiveGroup active_group;
   return field_trial && field_trial->GetActiveGroup(&active_group);
 }
@@ skipping 276 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.
@@ skipping 52 matching lines @@
 
   // 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);
-  pickle.WriteString(trial_state.group_name);
+  if (!PickleFieldTrialState(trial_state, &pickle))
+    return;
 
   size_t total_size = sizeof(FieldTrialEntry) + pickle.size();
   SharedPersistentMemoryAllocator::Reference ref =
       allocator->Allocate(total_size, kFieldTrialType);
   if (ref == SharedPersistentMemoryAllocator::kReferenceNull)
     return;
 
   FieldTrialEntry* entry =
       allocator->GetAsObject<FieldTrialEntry>(ref, kFieldTrialType);
   entry->activated = trial_state.activated;
@@ skipping 53 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