Revert "reland 2: "mac: Run A/B experiment on SharedMemory mechanism for resource buffers.""

base/memory/shared_memory_mac.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/memory/shared_memory.h"
 
 #include <fcntl.h>
 #include <mach/mach_vm.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
-#include "base/mac/mac_util.h"
 #include "base/mac/scoped_mach_vm.h"
-#include "base/metrics/field_trial.h"
-#include "base/metrics/histogram_macros.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/safe_strerror.h"
 #include "base/process/process_metrics.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/scoped_generic.h"
 #include "base/strings/utf_string_conversions.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/foundation_util.h"
 #endif  // OS_MACOSX
 
 namespace base {
 
 namespace {
 
-const char kTrialName[] = "MacMemoryMechanism";
-const char kTrialMach[] = "Mach";
-const char kTrialPosix[] = "Posix";
-
-SharedMemoryHandle::Type GetABTestMechanism() {
-  static bool found_group = false;
-  static SharedMemoryHandle::Type group = SharedMemoryHandle::MACH;
-
-  if (found_group)
-    return group;
-
-  const std::string group_name =
-      base::FieldTrialList::FindFullName(kTrialName);
-  if (group_name == kTrialMach) {
-    group = SharedMemoryHandle::MACH;
-    found_group = true;
-  } else if (group_name == kTrialPosix) {
-    group = SharedMemoryHandle::POSIX;
-    found_group = true;
-  } else {
-    group = SharedMemoryHandle::MACH;
-  }
-
-  return group;
-}
-
-// Emits a histogram entry indicating which type of SharedMemory was created.
-void EmitMechanism(SharedMemoryHandle::Type type) {
-  UMA_HISTOGRAM_ENUMERATION("OSX.SharedMemory.Mechanism", type,
-                            SharedMemoryHandle::TypeMax);
-}
-
 // Returns whether the operation succeeded.
 // |new_handle| is an output variable, populated on success. The caller takes
 // ownership of the underlying memory object.
 // |handle| is the handle to copy.
 // If |handle| is already mapped, |mapped_addr| is its mapped location.
 // Otherwise, |mapped_addr| should be |nullptr|.
 bool MakeMachSharedMemoryHandleReadOnly(SharedMemoryHandle* new_handle,
                                         SharedMemoryHandle handle,
                                         void* mapped_addr) {
   if (!handle.IsValid())
@@ skipping 178 matching lines @@
   return CreateAnonymousPosix(size) && Map(size);
 }
 
 bool SharedMemory::CreateAnonymousPosix(size_t size) {
   SharedMemoryCreateOptions options;
   options.type = SharedMemoryHandle::POSIX;
   options.size = size;
   return Create(options);
 }
 
-bool SharedMemory::CreateAndMapAnonymousMach(size_t size) {
-  SharedMemoryCreateOptions options;
-
-  if (mac::IsOSLionOrLater()) {
-    // A/B test the mechanism. Once the experiment is over, this will always be
-    // set to SharedMemoryHandle::MACH.
-    // http://crbug.com/547261
-    options.type = GetABTestMechanism();
-  } else {
-    // Mach shared memory isn't supported on OSX 10.6 or older.
-    options.type = SharedMemoryHandle::POSIX;
-  }
-  options.size = size;
-  return Create(options) && Map(size);
-}
-
 // static
 bool SharedMemory::GetSizeFromSharedMemoryHandle(
     const SharedMemoryHandle& handle,
     size_t* size) {
   return handle.GetSize(size);
 }
 
 // Chromium mostly only uses the unique/private shmem as specified by
 // "name == L"". The exception is in the StatsTable.
 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
   // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466437
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "466437 SharedMemory::Create::Start"));
   DCHECK(!shm_.IsValid());
   if (options.size == 0) return false;
 
   if (options.size > static_cast<size_t>(std::numeric_limits<int>::max()))
     return false;
 
-  EmitMechanism(options.type);
-
   if (options.type == SharedMemoryHandle::MACH) {
     shm_ = SharedMemoryHandle(options.size);
     requested_size_ = options.size;
     return shm_.IsValid();
   }
 
   // This function theoretically can block on the disk. Both profiling of real
   // users and local instrumentation shows that this is a real problem.
   // https://code.google.com/p/chromium/issues/detail?id=466437
   base::ThreadRestrictions::ScopedAllowIO allow_io;
@@ skipping 180 matching lines @@
 
   if (close_self) {
     Unmap();
     Close();
   }
 
   return true;
 }
 
 }  // namespace base