Enable field trial shared memory segment on Android.

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"
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial_param_associator.h"
 #include "base/process/memory.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 
-// On systems that use the zygote process to spawn child processes, we must
-// retrieve the correct fd using the mapping in GlobalDescriptors.
-#if defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_MACOSX) && \
-    !defined(OS_ANDROID)
-#define POSIX_WITH_ZYGOTE 1
-#endif
-
-#if defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
+// On POSIX, the fd is shared using the mapping in GlobalDescriptors.
+#if defined(OS_POSIX) && !defined(OS_NACL)
 #include "base/posix/global_descriptors.h"
 #endif
 
 namespace base {
 
 namespace {
 
 // Define a separator character to use when creating a persistent form of an
 // instance.  This is intended for use as a command line argument, passed to a
 // second process to mimic our state (i.e., provide the same group name).
@@ skipping 16 matching lines @@
 // Constants for the field trial allocator.
 const char kAllocatorName[] = "FieldTrialAllocator";
 
 // 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
-#endif
 
 // Writes out string1 and then string2 to pickle.
 bool WriteStringPair(Pickle* pickle,
                      const StringPiece& string1,
                      const StringPiece& string2) {
   if (!pickle->WriteString(string1))
     return false;
   if (!pickle->WriteString(string2))
     return false;
   return true;
@@ skipping 132 matching lines @@
   HANDLE src = allocator->shared_memory()->handle().GetHandle();
   ProcessHandle process = GetCurrentProcess();
   DWORD access = SECTION_MAP_READ | SECTION_QUERY;
   HANDLE dst;
   if (!::DuplicateHandle(process, src, process, &dst, access, true, 0))
     return kInvalidPlatformFile;
   return dst;
 }
 #endif
 
-#if defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
+#if defined(OS_POSIX) && !defined(OS_NACL)
 int CreateReadOnlyHandle(FieldTrialList::FieldTrialAllocator* allocator) {
   SharedMemoryHandle new_handle;
   allocator->shared_memory()->ShareReadOnlyToProcess(GetCurrentProcessHandle(),
                                                      &new_handle);
   return SharedMemory::GetFdFromSharedMemoryHandle(new_handle);
 }
 #endif
 
+void OnOutOfMemory(size_t size) {
+#if defined(OS_NACL)
+  NOTREACHED();
+#else
+  TerminateBecauseOutOfMemory(size);
+#endif
+}
+
 }  // namespace
 
 // statics
 const int FieldTrial::kNotFinalized = -1;
 const int FieldTrial::kDefaultGroupNumber = 0;
 bool FieldTrial::enable_benchmarking_ = false;
 
 int FieldTrialList::kNoExpirationYear = 0;
 
 //------------------------------------------------------------------------------
@@ skipping 532 matching lines @@
 
 #if defined(OS_WIN)
   if (cmd_line.HasSwitch(field_trial_handle_switch)) {
     std::string handle_switch =
         cmd_line.GetSwitchValueASCII(field_trial_handle_switch);
     bool result = CreateTrialsFromHandleSwitch(handle_switch);
     DCHECK(result);
   }
 #endif
 
-#if defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
+#if defined(OS_POSIX) && !defined(OS_NACL)
   // On POSIX, we check if the handle is valid by seeing if the browser process
   // sent over the switch (we don't care about the value). Invalid handles
   // occur in some browser tests which don't initialize the allocator.
   if (cmd_line.HasSwitch(field_trial_handle_switch)) {
     bool result = CreateTrialsFromDescriptor(fd_key);
     DCHECK(result);
   }
 #endif
 
   if (cmd_line.HasSwitch(switches::kForceFieldTrials)) {
@@ skipping 15 matching lines @@
       !global_->field_trial_allocator_.get()) {
     return feature_list->InitializeFromCommandLine(
         command_line.GetSwitchValueASCII(enable_features_switch),
         command_line.GetSwitchValueASCII(disable_features_switch));
   }
 
   feature_list->InitializeFromSharedMemory(
       global_->field_trial_allocator_.get());
 }
 
-#if defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
-// static
-bool FieldTrialList::CreateTrialsFromDescriptor(int fd_key) {
-  if (!kUseSharedMemoryForFieldTrials)
-    return false;
-
-  if (fd_key == -1)
-    return false;
-
-  int fd = GlobalDescriptors::GetInstance()->MaybeGet(fd_key);
-  if (fd == -1)
-    return false;
-
-#if defined(POSIX_WITH_ZYGOTE)
-  SharedMemoryHandle shm_handle(fd, true);
-#elif defined(OS_MACOSX)
-  SharedMemoryHandle shm_handle(FileDescriptor(fd, true));
-#endif
-
-  bool result = FieldTrialList::CreateTrialsFromSharedMemoryHandle(shm_handle);
-  DCHECK(result);
-  return true;
-}
-#endif
-
 #if defined(OS_WIN)
 // static
 void FieldTrialList::AppendFieldTrialHandleIfNeeded(
     HandlesToInheritVector* handles) {
   if (!global_)
     return;
   if (kUseSharedMemoryForFieldTrials) {
     InstantiateFieldTrialAllocatorIfNeeded();
     if (global_->readonly_allocator_handle_)
       handles->push_back(global_->readonly_allocator_handle_);
@@ skipping 23 matching lines @@
   // content browser tests currently don't create a FieldTrialList because they
   // don't run ChromeBrowserMainParts code where it's done for Chrome.
   // Some tests depend on the enable and disable features flag switch, though,
   // so we can still add those even though AllStatesToString() will be a no-op.
   if (!global_) {
     AddFeatureAndFieldTrialFlags(enable_features_switch,
                                  disable_features_switch, cmd_line);
     return;
   }
 
-#if defined(OS_WIN) || defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
   // Use shared memory to pass the state if the feature is enabled, otherwise
   // fallback to passing it via the command line as a string.
   if (kUseSharedMemoryForFieldTrials) {
     InstantiateFieldTrialAllocatorIfNeeded();
     // If the readonly handle didn't get duplicated properly, then fallback to
     // original behavior.
     if (global_->readonly_allocator_handle_ == kInvalidPlatformFile) {
       AddFeatureAndFieldTrialFlags(enable_features_switch,
                                    disable_features_switch, cmd_line);
       return;
     }
 
     global_->field_trial_allocator_->UpdateTrackingHistograms();
 
 #if defined(OS_WIN)
     // We need to pass a named anonymous handle to shared memory over the
     // command line on Windows, since the child doesn't know which of the
     // handles it inherited it should open.
     // PlatformFile is typedef'd to HANDLE which is typedef'd to void *. We
     // basically cast the handle into an int (uintptr_t, to be exact), stringify
     // the int, and pass it as a command-line flag. The child process will do
     // the reverse conversions to retrieve the handle. See
     // http://stackoverflow.com/a/153077
     auto uintptr_handle =
         reinterpret_cast<uintptr_t>(global_->readonly_allocator_handle_);
     std::string field_trial_handle = std::to_string(uintptr_handle);
     cmd_line->AppendSwitchASCII(field_trial_handle_switch, field_trial_handle);
-#elif defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
+#elif defined(OS_POSIX)
     // On POSIX, we dup the fd into a fixed fd kFieldTrialDescriptor, so we
     // don't have to pass over the handle (it's not even the right handle
     // anyways). But some browser tests don't create the allocator, so we need
     // to be able to distinguish valid and invalid handles. We do that by just
     // checking that the flag is set with a dummy value.
     cmd_line->AppendSwitchASCII(field_trial_handle_switch, "1");
+#else
+#error Unsupported OS
 #endif
     return;
   }
-#endif
 
   AddFeatureAndFieldTrialFlags(enable_features_switch, disable_features_switch,
                                cmd_line);
 }
 
 // static
 FieldTrial* FieldTrialList::CreateFieldTrial(
     const std::string& name,
     const std::string& group_name) {
   DCHECK(global_);
@@ skipping 207 matching lines @@
 // static
 bool FieldTrialList::CreateTrialsFromHandleSwitch(
     const std::string& handle_switch) {
   int field_trial_handle = std::stoi(handle_switch);
   HANDLE handle = reinterpret_cast<HANDLE>(field_trial_handle);
   SharedMemoryHandle shm_handle(handle, GetCurrentProcId());
   return FieldTrialList::CreateTrialsFromSharedMemoryHandle(shm_handle);
 }
 #endif
 
-#if !defined(OS_NACL)
+#if defined(OS_POSIX) && !defined(OS_NACL)
+// static
+bool FieldTrialList::CreateTrialsFromDescriptor(int fd_key) {
+  if (!kUseSharedMemoryForFieldTrials)
+    return false;
+
+  if (fd_key == -1)
+    return false;
+
+  int fd = GlobalDescriptors::GetInstance()->MaybeGet(fd_key);
+  if (fd == -1)
+    return false;
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  SharedMemoryHandle shm_handle(FileDescriptor(fd, true));
+#else
+  SharedMemoryHandle shm_handle(fd, true);
+#endif
+
+  bool result = FieldTrialList::CreateTrialsFromSharedMemoryHandle(shm_handle);
+  DCHECK(result);
+  return true;
+}
+#endif
+
 // static
 bool FieldTrialList::CreateTrialsFromSharedMemoryHandle(
     SharedMemoryHandle shm_handle) {
   // shm gets deleted when it gets out of scope, but that's OK because we need
   // it only for the duration of this method.
   std::unique_ptr<SharedMemory> shm(new SharedMemory(shm_handle, true));
   if (!shm.get()->Map(kFieldTrialAllocationSize))
-    TerminateBecauseOutOfMemory(kFieldTrialAllocationSize);
+    OnOutOfMemory(kFieldTrialAllocationSize);
 
   return FieldTrialList::CreateTrialsFromSharedMemory(std::move(shm));
 }
-#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);
 
   const FieldTrial::FieldTrialEntry* entry;
@@ skipping 13 matching lines @@
     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;
 }
 
-#if !defined(OS_NACL)
 // static
 void FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded() {
   if (!global_)
     return;
   AutoLock auto_lock(global_->lock_);
   // Create the allocator if not already created and add all existing trials.
   if (global_->field_trial_allocator_ != nullptr)
     return;
 
   SharedMemoryCreateOptions options;
   options.size = kFieldTrialAllocationSize;
   options.share_read_only = true;
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   options.type = SharedMemoryHandle::POSIX;
 #endif
 
   std::unique_ptr<SharedMemory> shm(new SharedMemory());
   if (!shm->Create(options))
-    TerminateBecauseOutOfMemory(kFieldTrialAllocationSize);
+    OnOutOfMemory(kFieldTrialAllocationSize);
 
   if (!shm->Map(kFieldTrialAllocationSize))
-    TerminateBecauseOutOfMemory(kFieldTrialAllocationSize);
+    OnOutOfMemory(kFieldTrialAllocationSize);
 
   global_->field_trial_allocator_.reset(
       new FieldTrialAllocator(std::move(shm), 0, kAllocatorName, false));
   global_->field_trial_allocator_->CreateTrackingHistograms(kAllocatorName);
 
   // Add all existing field trials.
   for (const auto& registered : global_->registered_) {
     AddToAllocatorWhileLocked(global_->field_trial_allocator_.get(),
                               registered.second);
   }
 
   // Add all existing features.
   FeatureList::GetInstance()->AddFeaturesToAllocator(
       global_->field_trial_allocator_.get());
 
-#if defined(OS_WIN) || defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
+#if !defined(OS_NACL)
   // Set |readonly_allocator_handle_| so we can pass it to be inherited and
   // via the command line.
   global_->readonly_allocator_handle_ =
       CreateReadOnlyHandle(global_->field_trial_allocator_.get());
 #endif
 }
-#endif
 
 // static
 void FieldTrialList::AddToAllocatorWhileLocked(
     PersistentMemoryAllocator* allocator,
     FieldTrial* field_trial) {
   // Don't do anything if the allocator hasn't been instantiated yet.
   if (allocator == nullptr)
     return;
 
   // Or if the allocator is read only, which means we are in a child process and
@@ skipping 89 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