Improved support for objects inside persistent memory.

base/feature_list.cc

 // Copyright 2015 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/feature_list.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 10 matching lines @@
 namespace {
 
 // Pointer to the FeatureList instance singleton that was set via
 // FeatureList::SetInstance(). Does not use base/memory/singleton.h in order to
 // have more control over initialization timing. Leaky.
 FeatureList* g_instance = nullptr;
 
 // Tracks whether the FeatureList instance was initialized via an accessor.
 bool g_initialized_from_accessor = false;
 
-const uint32_t kFeatureType = 0x06567CA6 + 1;  // SHA1(FeatureEntry) v1
-
 // An allocator entry for a feature in shared memory. The FeatureEntry is
 // followed by a base::Pickle object that contains the feature and trial name.
-// Any changes to this structure requires a bump in kFeatureType defined above.
 struct FeatureEntry {
+  // SHA1(FeatureEntry): Increment this if structure changes!
+  static constexpr uint32_t kPersistentTypeId = 0x06567CA6 + 1;
+
   // Expected size for 32/64-bit check.
   static constexpr size_t kExpectedInstanceSize = 8;
 
   // Specifies whether a feature override enables or disables the feature. Same
   // values as the OverrideState enum in feature_list.h
   uint32_t override_state;
 
   // Size of the pickled structure, NOT the total size of this entry.
   uint32_t pickle_size;
 
@@ skipping 44 matching lines @@
   RegisterOverridesFromCommandLine(enable_features, OVERRIDE_ENABLE_FEATURE);
 
   initialized_from_command_line_ = true;
 }
 
 void FeatureList::InitializeFromSharedMemory(
     PersistentMemoryAllocator* allocator) {
   DCHECK(!initialized_);
 
   PersistentMemoryAllocator::Iterator iter(allocator);
-
-  PersistentMemoryAllocator::Reference ref;
-  while ((ref = iter.GetNextOfType(kFeatureType)) !=
-         PersistentMemoryAllocator::kReferenceNull) {
-    const FeatureEntry* entry =
-        allocator->GetAsObject<const FeatureEntry>(ref, kFeatureType);
-
+  const FeatureEntry* entry;
+  while ((entry = iter.GetNextOfObject<FeatureEntry>()) != nullptr) {
     OverrideState override_state =
         static_cast<OverrideState>(entry->override_state);
 
     StringPiece feature_name;
     StringPiece trial_name;
     if (!entry->GetFeatureAndTrialName(&feature_name, &trial_name))
       continue;
 
     FieldTrial* trial = FieldTrialList::Find(trial_name.as_string());
     RegisterOverride(feature_name, override_state, trial);
@@ skipping 45 matching lines @@
 void FeatureList::AddFeaturesToAllocator(PersistentMemoryAllocator* allocator) {
   DCHECK(initialized_);
 
   for (const auto& override : overrides_) {
     Pickle pickle;
     pickle.WriteString(override.first);
     if (override.second.field_trial)
       pickle.WriteString(override.second.field_trial->trial_name());
 
     size_t total_size = sizeof(FeatureEntry) + pickle.size();
-    PersistentMemoryAllocator::Reference ref =
-        allocator->Allocate(total_size, kFeatureType);
-    if (!ref)
+    FeatureEntry* entry = allocator->AllocateObject<FeatureEntry>(total_size);
+    if (!entry)
       return;
 
-    FeatureEntry* entry =
-        allocator->GetAsObject<FeatureEntry>(ref, kFeatureType);
     entry->override_state = override.second.overridden_state;
     entry->pickle_size = pickle.size();
 
     char* dst = reinterpret_cast<char*>(entry) + sizeof(FeatureEntry);
     memcpy(dst, pickle.data(), pickle.size());
 
-    allocator->MakeIterable(ref);
+    allocator->MakeIterable(entry);
   }
 }
 
 void FeatureList::GetFeatureOverrides(std::string* enable_overrides,
                                       std::string* disable_overrides) {
   DCHECK(initialized_);
 
   enable_overrides->clear();
   disable_overrides->clear();
 
@@ skipping 199 matching lines @@
   return it->second == &feature;
 }
 
 FeatureList::OverrideEntry::OverrideEntry(OverrideState overridden_state,
                                           FieldTrial* field_trial)
     : overridden_state(overridden_state),
       field_trial(field_trial),
       overridden_by_field_trial(field_trial != nullptr) {}
 
 }  // namespace base