Add field trial dump and retrieval methods 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"
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial_param_associator.h"
-#include "base/pickle.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"
 
 // On systems that use the zygote process to spawn child processes, we must
 // retrieve the correct fd using the mapping in GlobalDescriptors.
 #if defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_MACOSX) && \
@@ skipping 36 matching lines @@
 // as most people use 3 - 25 KiB for field trials (as of 11/25/2016).
 // 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.
-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 pickle_size;
-
-  // Returns an iterator over the data containing names and params.
-  PickleIterator GetPickleIterator() const {
-    const char* src =
-        reinterpret_cast<const char*>(this) + sizeof(FieldTrialEntry);
-
-    Pickle pickle(src, pickle_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 {
-    PickleIterator iter = GetPickleIterator();
-    return ReadStringPair(&iter, trial_name, group_name);
-  }
-
-  // Calling this is only valid when the entry is initialized as well. Reads the
-  // parameters following the trial and group name and stores them as key-value
-  // mappings in |params|.
-  bool GetParams(std::map<std::string, std::string>* params) const {
-    PickleIterator iter = GetPickleIterator();
-    StringPiece tmp;
-    if (!ReadStringPair(&iter, &tmp, &tmp))
-      return false;
-
-    while (true) {
-      StringPiece key;
-      StringPiece value;
-      if (!ReadStringPair(&iter, &key, &value))
-        return key.empty();  // Non-empty is bad: got one of a pair.
-      (*params)[key.as_string()] = value.as_string();
-    }
-  }
-};
-
 // Writes out string1 and then string2 to pickle.
 bool WriteStringPair(Pickle* pickle,
                      const StringPiece& string1,
                      const StringPiece& string2) {
   if (!pickle->WriteString(string1))
     return false;
   if (!pickle->WriteString(string2))
     return false;
   return true;
 }
@@ skipping 161 matching lines @@
 
 FieldTrial::EntropyProvider::~EntropyProvider() {
 }
 
 FieldTrial::State::State() : activated(false) {}
 
 FieldTrial::State::State(const State& other) = default;
 
 FieldTrial::State::~State() {}
 
+bool FieldTrial::FieldTrialEntry::GetTrialAndGroupName(
+    StringPiece* trial_name,
+    StringPiece* group_name) const {
+  PickleIterator iter = GetPickleIterator();
+  return ReadStringPair(&iter, trial_name, group_name);
+}
+
+bool FieldTrial::FieldTrialEntry::GetParams(
+    std::map<std::string, std::string>* params) const {
+  PickleIterator iter = GetPickleIterator();
+  StringPiece tmp;
+  // Skip reading trial and group name.
+  if (!ReadStringPair(&iter, &tmp, &tmp))
+    return false;
+
+  while (true) {
+    StringPiece key;
+    StringPiece value;
+    if (!ReadStringPair(&iter, &key, &value))
+      return key.empty();  // Non-empty is bad: got one of a pair.
+    (*params)[key.as_string()] = value.as_string();
+  }
+}
+
+PickleIterator FieldTrial::FieldTrialEntry::GetPickleIterator() const {
+  const char* src =
+      reinterpret_cast<const char*>(this) + sizeof(FieldTrialEntry);
+
+  Pickle pickle(src, pickle_size);
+  return PickleIterator(pickle);
+}
+
+bool FieldTrial::FieldTrialEntry::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;
+}
+
 void FieldTrial::Disable() {
   DCHECK(!group_reported_);
   enable_field_trial_ = false;
 
   // In case we are disabled after initialization, we need to switch
   // the trial to the default group.
   if (group_ != kNotFinalized) {
     // Only reset when not already the default group, because in case we were
     // forced to the default group, the group number may not be
     // kDefaultGroupNumber, so we should keep it as is.
@@ skipping 408 matching lines @@
         command_line.GetSwitchValueASCII(switches::kForceFieldTrials),
         active_groups);
     return;
   }
 
   FieldTrialAllocator* allocator = global_->field_trial_allocator_.get();
   FieldTrialAllocator::Iterator mem_iter(allocator);
   FieldTrial::FieldTrialRef ref;
   while ((ref = mem_iter.GetNextOfType(kFieldTrialType)) !=
          SharedPersistentMemoryAllocator::kReferenceNull) {
-    const FieldTrialEntry* entry =
-        allocator->GetAsObject<const FieldTrialEntry>(ref, kFieldTrialType);
+    const FieldTrial::FieldTrialEntry* entry =
+        allocator->GetAsObject<const FieldTrial::FieldTrialEntry>(
+            ref, kFieldTrialType);
 
     StringPiece trial_name;
     StringPiece group_name;
     if (entry->activated &&
         entry->GetTrialAndGroupName(&trial_name, &group_name)) {
       FieldTrial::ActiveGroup group;
       group.trial_name = trial_name.as_string();
       group.group_name = group_name.as_string();
       active_groups->push_back(group);
     }
@@ skipping 221 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);
+    AddToAllocatorWhileLocked(global_->field_trial_allocator_.get(),
+                              field_trial);
   } else {
     AutoLock auto_lock(global_->lock_);
-    AddToAllocatorWhileLocked(field_trial);
+    AddToAllocatorWhileLocked(global_->field_trial_allocator_.get(),
+                              field_trial);
   }
 }
 
 // static
 void FieldTrialList::NotifyFieldTrialGroupSelection(FieldTrial* field_trial) {
   if (!global_)
     return;
 
   {
     AutoLock auto_lock(global_->lock_);
@@ skipping 38 matching lines @@
   //   allocator should get set up very early in the lifecycle. Try to see if
   //   you can call it after it's been set up.
   AutoLock auto_lock(global_->lock_);
   if (!global_->field_trial_allocator_)
     return false;
 
   // If ref_ isn't set, then the field trial data can't be in shared memory.
   if (!field_trial->ref_)
     return false;
 
-  const FieldTrialEntry* entry =
-      global_->field_trial_allocator_->GetAsObject<const FieldTrialEntry>(
-          field_trial->ref_, kFieldTrialType);
+  const FieldTrial::FieldTrialEntry* entry =
+      global_->field_trial_allocator_
+          ->GetAsObject<const FieldTrial::FieldTrialEntry>(field_trial->ref_,
+                                                           kFieldTrialType);
 
   size_t allocated_size =
       global_->field_trial_allocator_->GetAllocSize(field_trial->ref_);
-  size_t actual_size = sizeof(FieldTrialEntry) + entry->pickle_size;
+  size_t actual_size = sizeof(FieldTrial::FieldTrialEntry) + entry->pickle_size;
   if (allocated_size < actual_size)
     return false;
 
   return entry->GetParams(params);
 }
 
 // static
 void FieldTrialList::ClearParamsFromSharedMemoryForTesting() {
   if (!global_)
     return;
 
   AutoLock auto_lock(global_->lock_);
   if (!global_->field_trial_allocator_)
     return;
 
   // To clear the params, we iterate through every item in the allocator, copy
   // just the trial and group name into a newly-allocated segment and then clear
   // the existing item.
   FieldTrialAllocator* allocator = global_->field_trial_allocator_.get();
   FieldTrialAllocator::Iterator mem_iter(allocator);
 
   // List of refs to eventually be made iterable. We can't make it in the loop,
   // since it would go on forever.
   std::vector<FieldTrial::FieldTrialRef> new_refs;
 
   FieldTrial::FieldTrialRef prev_ref;
   while ((prev_ref = mem_iter.GetNextOfType(kFieldTrialType)) !=
          FieldTrialAllocator::kReferenceNull) {
     // Get the existing field trial entry in shared memory.
-    const FieldTrialEntry* prev_entry =
-        allocator->GetAsObject<const FieldTrialEntry>(prev_ref,
-                                                      kFieldTrialType);
+    const FieldTrial::FieldTrialEntry* prev_entry =
+        allocator->GetAsObject<const FieldTrial::FieldTrialEntry>(
+            prev_ref, kFieldTrialType);
     StringPiece trial_name;
     StringPiece group_name;
     if (!prev_entry->GetTrialAndGroupName(&trial_name, &group_name))
       continue;
 
     // Write a new entry, minus the params.
     Pickle pickle;
     pickle.WriteString(trial_name);
     pickle.WriteString(group_name);
-    size_t total_size = sizeof(FieldTrialEntry) + pickle.size();
+    size_t total_size = sizeof(FieldTrial::FieldTrialEntry) + pickle.size();
     FieldTrial::FieldTrialRef new_ref =
         allocator->Allocate(total_size, kFieldTrialType);
-    FieldTrialEntry* new_entry =
-        allocator->GetAsObject<FieldTrialEntry>(new_ref, kFieldTrialType);
+    FieldTrial::FieldTrialEntry* new_entry =
+        allocator->GetAsObject<FieldTrial::FieldTrialEntry>(new_ref,
+                                                            kFieldTrialType);
     new_entry->activated = prev_entry->activated;
     new_entry->pickle_size = pickle.size();
 
     // TODO(lawrencewu): Modify base::Pickle to be able to write over a section
     // in memory, so we can avoid this memcpy.
-    char* dst = reinterpret_cast<char*>(new_entry) + sizeof(FieldTrialEntry);
+    char* dst = reinterpret_cast<char*>(new_entry) +
+                sizeof(FieldTrial::FieldTrialEntry);
     memcpy(dst, pickle.data(), pickle.size());
 
     // Update the ref on the field trial and add it to the list to be made
     // iterable.
     FieldTrial* trial = global_->PreLockedFind(trial_name.as_string());
     trial->ref_ = new_ref;
     new_refs.push_back(new_ref);
 
     // Mark the existing entry as unused.
     allocator->ChangeType(prev_ref, 0, kFieldTrialType);
   }
 
   for (const auto& ref : new_refs) {
     allocator->MakeIterable(ref);
   }
 }
 
+// static
+void FieldTrialList::DumpAllFieldTrialsToPersistentAllocator(
+    PersistentMemoryAllocator* allocator) {
+  if (!global_)
+    return;
+  AutoLock auto_lock(global_->lock_);
+  for (const auto& registered : global_->registered_) {
+    AddToAllocatorWhileLocked(allocator, registered.second);
+  }
+}
+
+// static
+std::vector<const FieldTrial::FieldTrialEntry*>
+FieldTrialList::GetAllFieldTrialsFromPersistentAllocator(
+    PersistentMemoryAllocator const& allocator) {
+  std::vector<const FieldTrial::FieldTrialEntry*> entries;
+  FieldTrial::FieldTrialRef ref;
+  FieldTrialAllocator::Iterator iter(&allocator);
+  while ((ref = iter.GetNextOfType(kFieldTrialType)) !=
+         FieldTrialAllocator::kReferenceNull) {
+    const FieldTrial::FieldTrialEntry* entry =
+        allocator.GetAsObject<const FieldTrial::FieldTrialEntry>(
+            ref, kFieldTrialType);
+    entries.push_back(entry);
+  }
+  return entries;
+}
+
 #if defined(OS_WIN)
 // static
 bool FieldTrialList::CreateTrialsFromHandleSwitch(
     const std::string& handle_switch) {
   int field_trial_handle = std::stoi(handle_switch);
   HANDLE handle = reinterpret_cast<HANDLE>(field_trial_handle);
   SharedMemoryHandle shm_handle(handle, GetCurrentProcId());
   return FieldTrialList::CreateTrialsFromSharedMemoryHandle(shm_handle);
 }
 #endif
@@ skipping 16 matching lines @@
 bool FieldTrialList::CreateTrialsFromSharedMemory(
     std::unique_ptr<SharedMemory> shm) {
   global_->field_trial_allocator_.reset(
       new FieldTrialAllocator(std::move(shm), 0, kAllocatorName, true));
   FieldTrialAllocator* shalloc = global_->field_trial_allocator_.get();
   FieldTrialAllocator::Iterator mem_iter(shalloc);
 
   FieldTrial::FieldTrialRef ref;
   while ((ref = mem_iter.GetNextOfType(kFieldTrialType)) !=
          FieldTrialAllocator::kReferenceNull) {
-    const FieldTrialEntry* entry =
-        shalloc->GetAsObject<const FieldTrialEntry>(ref, kFieldTrialType);
+    const FieldTrial::FieldTrialEntry* entry =
+        shalloc->GetAsObject<const FieldTrial::FieldTrialEntry>(
+            ref, kFieldTrialType);
 
     StringPiece trial_name;
     StringPiece group_name;
     if (!entry->GetTrialAndGroupName(&trial_name, &group_name))
       return false;
 
     // TODO(lawrencewu): Convert the API for CreateFieldTrial to take
     // StringPieces.
     FieldTrial* trial =
         CreateFieldTrial(trial_name.as_string(), group_name.as_string());
@@ skipping 29 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);
+    AddToAllocatorWhileLocked(global_->field_trial_allocator_.get(),
+                              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) {
-  FieldTrialAllocator* allocator = global_->field_trial_allocator_.get();
-
+void FieldTrialList::AddToAllocatorWhileLocked(
+    PersistentMemoryAllocator* allocator,
+    FieldTrial* field_trial) {
   // 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;
 
   FieldTrial::State trial_state;
   if (!field_trial->GetStateWhileLocked(&trial_state))
     return;
 
   // Or if we've already added it. We must check after GetState since it can
   // also add to the allocator.
   if (field_trial->ref_)
     return;
 
   Pickle pickle;
   if (!PickleFieldTrial(trial_state, &pickle)) {
     NOTREACHED();
     return;
   }
 
-  size_t total_size = sizeof(FieldTrialEntry) + pickle.size();
+  size_t total_size = sizeof(FieldTrial::FieldTrialEntry) + pickle.size();
   FieldTrial::FieldTrialRef ref =
       allocator->Allocate(total_size, kFieldTrialType);
   if (ref == FieldTrialAllocator::kReferenceNull) {
     NOTREACHED();
     return;
   }
 
-  FieldTrialEntry* entry =
-      allocator->GetAsObject<FieldTrialEntry>(ref, kFieldTrialType);
+  FieldTrial::FieldTrialEntry* entry =
+      allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref, kFieldTrialType);
   entry->activated = trial_state.activated;
   entry->pickle_size = pickle.size();
 
   // TODO(lawrencewu): Modify base::Pickle to be able to write over a section in
   // memory, so we can avoid this memcpy.
-  char* dst = reinterpret_cast<char*>(entry) + sizeof(FieldTrialEntry);
+  char* dst =
+      reinterpret_cast<char*>(entry) + sizeof(FieldTrial::FieldTrialEntry);
   memcpy(dst, pickle.data(), pickle.size());
 
   allocator->MakeIterable(ref);
   field_trial->ref_ = ref;
 }
 
 // static
 void FieldTrialList::ActivateFieldTrialEntryWhileLocked(
     FieldTrial* field_trial) {
   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);
+    AddToAllocatorWhileLocked(global_->field_trial_allocator_.get(),
+                              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);
+    FieldTrial::FieldTrialEntry* entry =
+        allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref,
+                                                            kFieldTrialType);
     entry->activated = true;
   }
 }
 
 // static
 const FieldTrial::EntropyProvider*
     FieldTrialList::GetEntropyProviderForOneTimeRandomization() {
   if (!global_) {
     used_without_global_ = true;
     return NULL;
@@ skipping 16 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