Use SharedPersistentMemoryAllocator to share field trial state

base/metrics/field_trial.h

 // 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.
 
 // FieldTrial is a class for handling details of statistical experiments
 // performed by actual users in the field (i.e., in a shipped or beta product).
 // All code is called exclusively on the UI thread currently.
 //
 // The simplest example is an experiment to see whether one of two options
 // produces "better" results across our user population.  In that scenario, UMA
@@ skipping 51 matching lines @@
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/command_line.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/shared_memory.h"
+#include "base/metrics/persistent_memory_allocator.h"
 #include "base/observer_list_threadsafe.h"
+#include "base/process/launch.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 
 namespace base {
 
 class FieldTrialList;
 
 class BASE_EXPORT FieldTrial : public RefCounted<FieldTrial> {
  public:
@@ skipping 389 matching lines @@
   // If using shared memory to pass around the list of field trials, then
   // expects |field_trial_handle_switch| command line argument to
   // contain the shared memory handle.
   // If not, then create the trials as before (using the kForceFieldTrials
   // switch). Needs the |field_trial_handle_switch| argument to be passed in
   // since base/ can't depend on content/.
   static void CreateTrialsFromCommandLine(
       const base::CommandLine& cmd_line,
       const char* field_trial_handle_switch);
 
+#if defined(OS_WIN)
+  static void AppendFieldTrialHandleIfNeeded(

[Alexei Svitkine (slow), 2016/10/21 18:20:26]

Add a comment, please.

[lawrencewu, 2016/10/21 20:23:13]

Done.

+      base::HandlesToInheritVector* handles);
+#endif
+
   // Adds a switch to the command line containing the field trial state as a
   // string (if not using shared memory to share field trial state), or the
   // shared memory handle + length.
   // Needs the |field_trial_handle_switch| argument to be passed in since base/
   // can't depend on content/.
-  static std::unique_ptr<base::SharedMemory> CopyFieldTrialStateToFlags(
-      const char* field_trial_handle_switch,
-      base::CommandLine* cmd_line);
+  static void CopyFieldTrialStateToFlags(const char* field_trial_handle_switch,
+                                         base::CommandLine* cmd_line);
+
+  // Returns a pointer to the global field trial allocator object for testing.
+  static base::SharedPersistentMemoryAllocator*
+  GetFieldTrialAllocatorForTesting();
 
   // Create a FieldTrial with the given |name| and using 100% probability for
   // the FieldTrial, force FieldTrial to have the same group string as
   // |group_name|. This is commonly used in a non-browser process, to carry
   // randomly selected state in a browser process into this non-browser process.
   // It returns NULL if there is a FieldTrial that is already registered with
   // the same |name| but has different finalized group string (|group_name|).
   static FieldTrial* CreateFieldTrial(const std::string& name,
                                       const std::string& group_name);
 
   // Add an observer to be notified when a field trial is irrevocably committed
   // to being part of some specific field_group (and hence the group_name is
   // also finalized for that field_trial).
   static void AddObserver(Observer* observer);
 
   // Remove an observer.
   static void RemoveObserver(Observer* observer);
 
   // Notify all observers that a group has been finalized for |field_trial|.
   static void NotifyFieldTrialGroupSelection(FieldTrial* field_trial);
 
   // Return the number of active field trials.
   static size_t GetFieldTrialCount();
 
  private:
+  // Allow tests to access our innards for testing purposes.
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, InstantiateAllocator);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, AddTrialsToAllocator);
+
+  // Expects a mapped piece of shared memory |shm| that was created from the
+  // browser process's field_trial_allocator and shared via the command line.
+  // This function recreates the allocator, iterates through all the field
+  // trials in it, and creates them via CreateFieldTrial().
+  static void CreateTrialsFromSharedMemory(
+      std::unique_ptr<base::SharedMemory> shm);
+
+  // Instantiate the field trial allocator, add all existing field trials to it,
+  // and duplicates its handle to a read-only handle, which gets stored in
+  // |readonly_allocator_handle|.
+  static void InstantiateFieldTrialAllocatorIfNeeded();
+
+  // Called in NotifyFieldTrialGroupSelection() and afterinstantiating the

[Alexei Svitkine (slow), 2016/10/21 18:20:26]

Nit: I suggest removing the first sentence - the comment should mention what the
function does and where it's called from is already obvious from the rest of the
code.

[lawrencewu, 2016/10/21 20:23:13]

Done.

+  // allocator. Updates field_trial_allocator by adding the |field_trial|. Since
+  // the check for the allocator is not thread-safe, the caller must wrap this
+  // call in a lock.
+  static void UpdateFieldTrialAllocatorWhileLocked(FieldTrial* field_trial);
+
   // A map from FieldTrial names to the actual instances.
   typedef std::map<std::string, FieldTrial*> RegistrationMap;
 
   // If one-time randomization is enabled, returns a weak pointer to the
   // corresponding EntropyProvider. Otherwise, returns NULL.
   static const FieldTrial::EntropyProvider*
       GetEntropyProviderForOneTimeRandomization();
 
   // Helper function should be called only while holding lock_.
   FieldTrial* PreLockedFind(const std::string& name);
@@ skipping 17 matching lines @@
 
   std::map<std::string, std::string> seen_states_;
 
   // Entropy provider to be used for one-time randomized field trials. If NULL,
   // one-time randomization is not supported.
   std::unique_ptr<const FieldTrial::EntropyProvider> entropy_provider_;
 
   // List of observers to be notified when a group is selected for a FieldTrial.
   scoped_refptr<ObserverListThreadSafe<Observer> > observer_list_;
 
+  // Allocator used to instantiate field trial in child processes. In the
+  // future, we may want to move this to a more generic place if we want to
+  // start passing more data other than field trials.
+  std::unique_ptr<base::SharedPersistentMemoryAllocator> field_trial_allocator;

[Alexei Svitkine (slow), 2016/10/21 18:20:26]

Add _ at the end

[lawrencewu, 2016/10/21 20:23:13]

Done.

+
+#if defined(OS_WIN)
+  // Readonly copy of the handle to the allocator, stored here since we need it
+  // twice.

[Alexei Svitkine (slow), 2016/10/21 18:20:26]

"stored here since we need it twice" is very vague and doesn't tell me what it's
talking about.

Be more explicit, e.g.: "Needs to be a member variable because it's needed from
both CopyFieldTrialStateToFlags() and AppendFieldTrialHandleIfNeeded()."

[lawrencewu, 2016/10/21 20:23:13]

Done.

+  HANDLE readonly_allocator_handle;

[Alexei Svitkine (slow), 2016/10/21 18:20:26]

Add _ at the end

[lawrencewu, 2016/10/21 20:23:13]

Done.

+#endif
+
   DISALLOW_COPY_AND_ASSIGN(FieldTrialList);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_FIELD_TRIAL_H_