Share field trial allocator on zygote-using Linuxes

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 495 matching lines @@
   static void CreateTrialsFromCommandLine(
       const base::CommandLine& cmd_line,
       const char* field_trial_handle_switch);
 
 #if defined(OS_WIN)
   // On Windows, we need to explicitly pass down any handles to be inherited.
   // This function adds the shared memory handle to field trial state to the
   // list of handles to be inherited.
   static void AppendFieldTrialHandleIfNeeded(
       base::HandlesToInheritVector* handles);
+#elif defined(OS_POSIX)
+  // On POSIX, we also need to explicitly pass down any fds to be inherited via
+  // |files_to_register| in child_process_launcher.cc. This gets the handle so

[Alexei Svitkine (slow), 2016/11/24 17:44:34]

I don't think this should mention child_process_launcher.cc - which is in a
different layer.

I suggest just describing this more generally - i.e. the file descriptor that
should be shared with the child process.

[lawrencewu, 2016/11/24 18:16:13]

Done.

+  // we can add it to the mapping there. Returns -1 if no handle exists or was
+  // not initialized properly.
+  static int GetFieldTrialHandle();
 #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 void CopyFieldTrialStateToFlags(const char* field_trial_handle_switch,
                                          base::CommandLine* cmd_line);
 
@@ skipping 24 matching lines @@
   // 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);
   FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
                            DoNotAddSimulatedFieldTrialsToAllocator);
 
-#if defined(OS_WIN)
-  // Takes in |handle| that should have been retrieved from the command line and
-  // creates a SharedMemoryHandle from it, and then calls
-  // CreateTrialsFromSharedMemory(). Returns true on success, false on failure.
-  static bool CreateTrialsFromWindowsHandle(HANDLE handle);
-#endif
+  // Takes in |handle_switch| from the command line which represents the shared
+  // memory handle for field trials, parses it, and creates the field trials.
+  // Returns true on success, false on failure.
+  static bool CreateTrialsFromHandleSwitch(const std::string& handle_switch);
+
+  // Takes an unmapped SharedMemoryHandle, creates a SharedMemory object from it
+  // and maps it with the correct size.
+  static bool CreateTrialsFromSharedMemoryHandle(SharedMemoryHandle shm_handle);
 
   // 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(). Returns true if
   // successful and false otherwise.
   static bool CreateTrialsFromSharedMemory(
       std::unique_ptr<base::SharedMemory> shm);
 
   // Instantiate the field trial allocator, add all existing field trials to it,
@@ skipping 49 matching lines @@
   // browser and child processes, but readonly in the child.
   // 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<FieldTrialAllocator> field_trial_allocator_ = nullptr;
 
 #if defined(OS_WIN)
   // Readonly copy of the handle to the allocator. Needs to be a member variable
   // because it's needed from both CopyFieldTrialStateToFlags() and
   // AppendFieldTrialHandleIfNeeded().
   HANDLE readonly_allocator_handle_ = nullptr;
+#elif defined(OS_POSIX)
+  int readonly_allocator_handle_ = -1;

[Alexei Svitkine (slow), 2016/11/24 17:44:34]

Hmm, how about having this be the same var on Win and Posix and use PlatformFile
as the type - which is typedef'd to int on POSIX and HANDLE on Windows.

Them, you can use kInvalidPlatformFile for the default value and document that
as the return value of the other function.

[lawrencewu, 2016/11/24 18:16:13]

That's much cleaner, done.

 #endif
 
   // Tracks whether CreateTrialsFromCommandLine() has been called.
   bool create_trials_from_command_line_called_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(FieldTrialList);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_FIELD_TRIAL_H_