Share field trial allocator on MacOS

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"
@@ skipping 10 matching lines @@
 #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)
+#if defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
 #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 220 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)
+#if defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
 int CreateReadOnlyHandle(FieldTrialList::FieldTrialAllocator* allocator) {
   SharedMemoryHandle new_handle;
   allocator->shared_memory()->ShareReadOnlyToProcess(GetCurrentProcessHandle(),
                                                      &new_handle);
   return SharedMemory::GetFdFromSharedMemoryHandle(new_handle);
 }
 #endif
 
 }  // namespace
 
@@ skipping 500 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)
+#if defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
   // If we failed to create trials from the descriptor, fallback to the command
   // line. Otherwise we're good -- return.
   if (CreateTrialsFromDescriptor(fd_key))
     return;
 #endif
 
   if (cmd_line.HasSwitch(switches::kForceFieldTrials)) {
     bool result = FieldTrialList::CreateTrialsFromString(
         cmd_line.GetSwitchValueASCII(switches::kForceFieldTrials),
         std::set<std::string>());
     DCHECK(result);
   }
 }
 
-#if defined(POSIX_WITH_ZYGOTE)
+#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)
@@ skipping 35 matching lines @@
 // static
 void FieldTrialList::CopyFieldTrialStateToFlags(
     const char* field_trial_handle_switch,
     CommandLine* cmd_line) {
   // TODO(lawrencewu): Ideally, having the global would be guaranteed. However,
   // content browser tests currently don't create a FieldTrialList because they
   // don't run ChromeBrowserMainParts code where it's done for Chrome.
   if (!global_)
     return;
 
-#if defined(OS_WIN) || defined(POSIX_WITH_ZYGOTE)
+#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) {
       AddForceFieldTrialsFlag(cmd_line);
       return;
     }
@@ skipping 272 matching lines @@
   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)
+  options.type = SharedMemoryHandle::POSIX;
+#endif
 
   std::unique_ptr<SharedMemory> shm(new SharedMemory());
   if (!shm->Create(options))
     TerminateBecauseOutOfMemory(kFieldTrialAllocationSize);
 
   if (!shm->Map(kFieldTrialAllocationSize))
     TerminateBecauseOutOfMemory(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(registered.second);
   }
 
-#if defined(OS_WIN) || defined(POSIX_WITH_ZYGOTE)
+#if defined(OS_WIN) || defined(POSIX_WITH_ZYGOTE) || defined(OS_MACOSX)
   // 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(FieldTrial* field_trial) {
@@ skipping 94 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