Store and retrieve features from shared memory

base/feature_list.h

 // 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.
 
 #ifndef BASE_FEATURE_LIST_H_
 #define BASE_FEATURE_LIST_H_
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
+#include "base/metrics/persistent_memory_allocator.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/lock.h"
 
 namespace base {
 
 class FieldTrial;
 
 // Specifies whether a given feature is enabled or disabled by default.
 enum FeatureState {
   FEATURE_DISABLED_BY_DEFAULT,
@@ skipping 59 matching lines @@
   // it will be disabled. If a list entry has the format "FeatureName<TrialName"
   // then this initialization will also associate the feature state override
   // with the named field trial, if it exists. If a feature name is prefixed
   // with the '*' character, it will be created with OVERRIDE_USE_DEFAULT -
   // which is useful for associating with a trial while using the default state.
   // Must only be invoked during the initialization phase (before
   // FinalizeInitialization() has been called).
   void InitializeFromCommandLine(const std::string& enable_features,
                                  const std::string& disable_features);
 
+  // Initializes feature overrides through the field trial allocator, which
+  // we're using to store the feature names, their override state, and the name
+  // of the associated field trial.
+  void InitializeFromSharedMemory(SharedPersistentMemoryAllocator* allocator);

[bcwhite, 2016/12/01 20:15:15]

Better to accept the base PersistentMemoryAllocator class unless you're actually
going to access methods specific to the management of shared memory.  Here and
below.

[lawrencewu, 2016/12/02 19:24:46]

Done.

+
   // Specifies whether a feature override enables or disables the feature.
   enum OverrideState {
     OVERRIDE_USE_DEFAULT,
     OVERRIDE_DISABLE_FEATURE,
     OVERRIDE_ENABLE_FEATURE,
   };
 
   // Returns true if the state of |feature_name| has been overridden via
   // |InitializeFromCommandLine()|.
   bool IsFeatureOverriddenFromCommandLine(const std::string& feature_name,
@@ skipping 12 matching lines @@
   // feature to |override_state|. Command-line overrides still take precedence
   // over field trials, so this will have no effect if the feature is being
   // overridden from the command-line. The associated field trial will be
   // activated when the feature state for this feature is queried. This should
   // be called during registration, after InitializeFromCommandLine() has been
   // called but before the instance is registered via SetInstance().
   void RegisterFieldTrialOverride(const std::string& feature_name,
                                   OverrideState override_state,
                                   FieldTrial* field_trial);
 
+  // Loops through feature overrides and serializes them all into |allocator|.
+  void AddFeaturesToAllocator(SharedPersistentMemoryAllocator* allocator);
+
   // Returns comma-separated lists of feature names (in the same format that is
   // accepted by InitializeFromCommandLine()) corresponding to features that
   // have been overridden - either through command-line or via FieldTrials. For
   // those features that have an associated FieldTrial, the output entry will be
   // of the format "FeatureName<TrialName", where "TrialName" is the name of the
   // FieldTrial. Features that have overrides with OVERRIDE_USE_DEFAULT will be
   // added to |enable_overrides| with a '*' character prefix. Must be called
   // only after the instance has been initialized and registered.
   void GetFeatureOverrides(std::string* enable_overrides,
                            std::string* disable_overrides);
@@ skipping 36 matching lines @@
   // base::test::ScopedFeatureList.
   static std::unique_ptr<FeatureList> ClearInstanceForTesting();
 
   // Sets a given (initialized) |instance| to be the singleton feature list,
   // for testing. Existing instance must be null. This is primarily intended
   // to support base::test::ScopedFeatureList helper class.
   static void RestoreInstanceForTesting(std::unique_ptr<FeatureList> instance);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(FeatureListTest, CheckFeatureIdentity);
+  FRIEND_TEST_ALL_PREFIXES(FeatureListTest,
+                           StoreAndRetrieveFeaturesFromSharedMemory);
 
   struct OverrideEntry {
     // The overridden enable (on/off) state of the feature.
     const OverrideState overridden_state;
 
     // An optional associated field trial, which will be activated when the
     // state of the feature is queried for the first time. Weak pointer to the
     // FieldTrial object that is owned by the FieldTrialList singleton.
     base::FieldTrial* field_trial;
 
@@ skipping 68 matching lines @@
 
   // Whether this object has been initialized from command line.
   bool initialized_from_command_line_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(FeatureList);
 };
 
 }  // namespace base
 
 #endif  // BASE_FEATURE_LIST_H_