Improved support for objects inside persistent 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 37 matching lines @@
 // shared memory segment). See https://codereview.chromium.org/2365273004/ and
 // crbug.com/653874
 // The browser is the only process that has write access to the shared memory.
 // This is safe from race conditions because MakeIterable is a release operation
 // and GetNextOfType is an acquire operation, so memory writes before
 // MakeIterable happen before memory reads after GetNextOfType.
 const bool kUseSharedMemoryForFieldTrials = true;
 
 // Constants for the field trial allocator.
 const char kAllocatorName[] = "FieldTrialAllocator";
-const uint32_t kFieldTrialType = 0xABA17E13 + 2;  // SHA1(FieldTrialEntry) v2
 
 // We allocate 128 KiB to hold all the field trial data. This should be enough,
 // 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
@@ skipping 641 matching lines @@
 
   if (!global_->field_trial_allocator_) {
     GetActiveFieldTrialGroupsFromString(
         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 FieldTrial::FieldTrialEntry* entry =
-        allocator->GetAsObject<const FieldTrial::FieldTrialEntry>(
-            ref, kFieldTrialType);
-
+  const FieldTrial::FieldTrialEntry* entry;
+  while ((entry = mem_iter.GetNextOfObject<FieldTrial::FieldTrialEntry>()) !=
+         nullptr) {
     StringPiece trial_name;
     StringPiece group_name;
     if (subtle::NoBarrier_Load(&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 298 matching lines @@
   //   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 FieldTrial::FieldTrialEntry* entry =
-      global_->field_trial_allocator_
-          ->GetAsObject<const FieldTrial::FieldTrialEntry>(field_trial->ref_,
-                                                           kFieldTrialType);
+      global_->field_trial_allocator_->GetAsObject<FieldTrial::FieldTrialEntry>(
+          field_trial->ref_);
 
   size_t allocated_size =
       global_->field_trial_allocator_->GetAllocSize(field_trial->ref_);
   size_t actual_size = sizeof(FieldTrial::FieldTrialEntry) + entry->pickle_size;
   if (allocated_size < actual_size)
     return false;
 
   return entry->GetParams(params);
 }
 
@@ skipping 10 matching lines @@
   // 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)) !=
+  while ((prev_ref = mem_iter.GetNextOfType<FieldTrial::FieldTrialEntry>()) !=
          FieldTrialAllocator::kReferenceNull) {
     // Get the existing field trial entry in shared memory.
     const FieldTrial::FieldTrialEntry* prev_entry =
-        allocator->GetAsObject<const FieldTrial::FieldTrialEntry>(
-            prev_ref, kFieldTrialType);
+        allocator->GetAsObject<FieldTrial::FieldTrialEntry>(prev_ref);
     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(FieldTrial::FieldTrialEntry) + pickle.size();
-    FieldTrial::FieldTrialRef new_ref =
-        allocator->Allocate(total_size, kFieldTrialType);
     FieldTrial::FieldTrialEntry* new_entry =
-        allocator->GetAsObject<FieldTrial::FieldTrialEntry>(new_ref,
-                                                            kFieldTrialType);
+        allocator->AllocateObject<FieldTrial::FieldTrialEntry>(total_size);
     subtle::NoBarrier_Store(&new_entry->activated,
                             subtle::NoBarrier_Load(&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(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::FieldTrialRef new_ref = allocator->GetAsReference(new_entry);
     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);
+    allocator->ChangeType(prev_ref, 0,
+                          FieldTrial::FieldTrialEntry::kPersistentTypeId);
   }
 
   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);
+  const FieldTrial::FieldTrialEntry* entry;
+  while ((entry = iter.GetNextOfObject<FieldTrial::FieldTrialEntry>()) !=
+         nullptr) {
     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);
@@ skipping 18 matching lines @@
 #endif
 
 // static
 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 FieldTrial::FieldTrialEntry* entry =
-        shalloc->GetAsObject<const FieldTrial::FieldTrialEntry>(
-            ref, kFieldTrialType);
-
+  const FieldTrial::FieldTrialEntry* entry;
+  while ((entry = mem_iter.GetNextOfObject<FieldTrial::FieldTrialEntry>()) !=
+         nullptr) {
     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());
 
-    trial->ref_ = ref;
+    trial->ref_ = mem_iter.GetAsReference(entry);
     if (subtle::NoBarrier_Load(&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();
     }
   }
   return true;
 }
 
@@ skipping 66 matching lines @@
   if (field_trial->ref_)
     return;
 
   Pickle pickle;
   if (!PickleFieldTrial(trial_state, &pickle)) {
     NOTREACHED();
     return;
   }
 
   size_t total_size = sizeof(FieldTrial::FieldTrialEntry) + pickle.size();
-  FieldTrial::FieldTrialRef ref =
-      allocator->Allocate(total_size, kFieldTrialType);
+  FieldTrial::FieldTrialRef ref = allocator->Allocate(
+      total_size, FieldTrial::FieldTrialEntry::kPersistentTypeId);
   if (ref == FieldTrialAllocator::kReferenceNull) {
     NOTREACHED();
     return;
   }
 
   FieldTrial::FieldTrialEntry* entry =
-      allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref, kFieldTrialType);
+      allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref);
   subtle::NoBarrier_Store(&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(FieldTrial::FieldTrialEntry);
   memcpy(dst, pickle.data(), pickle.size());
 
   allocator->MakeIterable(ref);
@@ skipping 13 matching lines @@
   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(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.
     FieldTrial::FieldTrialEntry* entry =
-        allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref,
-                                                            kFieldTrialType);
+        allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref);
     subtle::NoBarrier_Store(&entry->activated, 1);
   }
 }
 
 // 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