Clean up Mac related files.

We droped to support libchrome on Mac host.
This CL cleans up Android.bp related to Mac,
and removes the files which are no longer used.

Bug: 72618679
Test: Build locally, ran Treehugger.
Change-Id: I50d0aec5707212be2163286d5c91904196a0be84

3 files changed, 0 insertions, 1007 deletions

diff --git a/base/memory/shared_memory_handle_mac.cc b/base/memory/shared_memory_handle_mac.cc
deleted file mode 100644
index 9dfd3c1aea..0000000000
--- a/base/memory/shared_memory_handle_mac.cc
+++ /dev/null
@@ -1,219 +0,0 @@
-// Copyright 2015 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_handle.h"
-
-#include <mach/mach_vm.h>
-#include <stddef.h>
-#include <sys/mman.h>
-#include <unistd.h>
-
-#include "base/mac/mac_util.h"
-#include "base/mac/mach_logging.h"
-#include "base/posix/eintr_wrapper.h"
-
-namespace base {
-
-SharedMemoryHandle::SharedMemoryHandle()
-    : type_(MACH), memory_object_(MACH_PORT_NULL) {}
-
-SharedMemoryHandle::SharedMemoryHandle(
-    const base::FileDescriptor& file_descriptor)
-    : type_(POSIX), file_descriptor_(file_descriptor) {}
-
-SharedMemoryHandle::SharedMemoryHandle(mach_vm_size_t size) {
-  type_ = MACH;
-  mach_port_t named_right;
-  kern_return_t kr = mach_make_memory_entry_64(
-      mach_task_self(),
-      &size,
-      0,  // Address.
-      MAP_MEM_NAMED_CREATE | VM_PROT_READ | VM_PROT_WRITE,
-      &named_right,
-      MACH_PORT_NULL);  // Parent handle.
-  if (kr != KERN_SUCCESS) {
-    memory_object_ = MACH_PORT_NULL;
-    return;
-  }
-
-  memory_object_ = named_right;
-  size_ = size;
-  pid_ = GetCurrentProcId();
-  ownership_passes_to_ipc_ = false;
-}
-
-SharedMemoryHandle::SharedMemoryHandle(mach_port_t memory_object,
-                                       mach_vm_size_t size,
-                                       base::ProcessId pid)
-    : type_(MACH),
-      memory_object_(memory_object),
-      size_(size),
-      pid_(pid),
-      ownership_passes_to_ipc_(false) {}
-
-SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle) {
-  CopyRelevantData(handle);
-}
-
-SharedMemoryHandle& SharedMemoryHandle::operator=(
-    const SharedMemoryHandle& handle) {
-  if (this == &handle)
-    return *this;
-
-  type_ = handle.type_;
-  CopyRelevantData(handle);
-  return *this;
-}
-
-SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
-  switch (type_) {
-    case POSIX: {
-      if (!IsValid())
-        return SharedMemoryHandle();
-      int duped_fd = HANDLE_EINTR(dup(file_descriptor_.fd));
-      if (duped_fd < 0)
-        return SharedMemoryHandle();
-      return SharedMemoryHandle(FileDescriptor(duped_fd, true));
-    }
-    case MACH: {
-      if (!IsValid())
-        return SharedMemoryHandle(MACH_PORT_NULL, 0, 0);
-
-      // Increment the ref count.
-      kern_return_t kr = mach_port_mod_refs(mach_task_self(), memory_object_,
-                                            MACH_PORT_RIGHT_SEND, 1);
-      DCHECK_EQ(kr, KERN_SUCCESS);
-      SharedMemoryHandle handle(*this);
-      handle.SetOwnershipPassesToIPC(true);
-      return handle;
-    }
-  }
-}
-
-bool SharedMemoryHandle::operator==(const SharedMemoryHandle& handle) const {
-  if (!IsValid() && !handle.IsValid())
-    return true;
-
-  if (type_ != handle.type_)
-    return false;
-
-  switch (type_) {
-    case POSIX:
-      return file_descriptor_.fd == handle.file_descriptor_.fd;
-    case MACH:
-      return memory_object_ == handle.memory_object_ && size_ == handle.size_ &&
-             pid_ == handle.pid_;
-  }
-}
-
-bool SharedMemoryHandle::operator!=(const SharedMemoryHandle& handle) const {
-  return !(*this == handle);
-}
-
-bool SharedMemoryHandle::IsValid() const {
-  switch (type_) {
-    case POSIX:
-      return file_descriptor_.fd >= 0;
-    case MACH:
-      return memory_object_ != MACH_PORT_NULL;
-  }
-}
-
-mach_port_t SharedMemoryHandle::GetMemoryObject() const {
-  DCHECK_EQ(type_, MACH);
-  return memory_object_;
-}
-
-bool SharedMemoryHandle::GetSize(size_t* size) const {
-  if (!IsValid()) {
-    *size = 0;
-    return true;
-  }
-
-  switch (type_) {
-    case SharedMemoryHandle::POSIX:
-      struct stat st;
-      if (fstat(file_descriptor_.fd, &st) != 0)
-        return false;
-      if (st.st_size < 0)
-        return false;
-      *size = st.st_size;
-      return true;
-    case SharedMemoryHandle::MACH:
-      *size = size_;
-      return true;
-  }
-}
-
-bool SharedMemoryHandle::MapAt(off_t offset,
-                               size_t bytes,
-                               void** memory,
-                               bool read_only) {
-  DCHECK(IsValid());
-  switch (type_) {
-    case SharedMemoryHandle::POSIX:
-      *memory = mmap(nullptr, bytes, PROT_READ | (read_only ? 0 : PROT_WRITE),
-                     MAP_SHARED, file_descriptor_.fd, offset);
-      return *memory != MAP_FAILED;
-    case SharedMemoryHandle::MACH:
-      DCHECK_EQ(pid_, GetCurrentProcId());
-      kern_return_t kr = mach_vm_map(
-          mach_task_self(),
-          reinterpret_cast<mach_vm_address_t*>(memory),    // Output parameter
-          bytes,
-          0,                                               // Alignment mask
-          VM_FLAGS_ANYWHERE,
-          memory_object_,
-          offset,
-          FALSE,                                           // Copy
-          VM_PROT_READ | (read_only ? 0 : VM_PROT_WRITE),  // Current protection
-          VM_PROT_WRITE | VM_PROT_READ | VM_PROT_IS_MASK,  // Maximum protection
-          VM_INHERIT_NONE);
-      return kr == KERN_SUCCESS;
-  }
-}
-
-void SharedMemoryHandle::Close() const {
-  if (!IsValid())
-    return;
-
-  switch (type_) {
-    case POSIX:
-      if (IGNORE_EINTR(close(file_descriptor_.fd)) < 0)
-        DPLOG(ERROR) << "Error closing fd";
-      break;
-    case MACH:
-      kern_return_t kr = mach_port_deallocate(mach_task_self(), memory_object_);
-      if (kr != KERN_SUCCESS)
-        MACH_DLOG(ERROR, kr) << "Error deallocating mach port";
-      break;
-  }
-}
-
-void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) {
-  DCHECK_EQ(type_, MACH);
-  ownership_passes_to_ipc_ = ownership_passes;
-}
-
-bool SharedMemoryHandle::OwnershipPassesToIPC() const {
-  DCHECK_EQ(type_, MACH);
-  return ownership_passes_to_ipc_;
-}
-
-void SharedMemoryHandle::CopyRelevantData(const SharedMemoryHandle& handle) {
-  type_ = handle.type_;
-  switch (type_) {
-    case POSIX:
-      file_descriptor_ = handle.file_descriptor_;
-      break;
-    case MACH:
-      memory_object_ = handle.memory_object_;
-      size_ = handle.size_;
-      pid_ = handle.pid_;
-      ownership_passes_to_ipc_ = handle.ownership_passes_to_ipc_;
-      break;
-  }
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_mac.cc b/base/memory/shared_memory_mac.cc
deleted file mode 100644
index c76d1626d6..0000000000
--- a/base/memory/shared_memory_mac.cc
+++ /dev/null
@@ -1,329 +0,0 @@
-// 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 <errno.h>
-#include <mach/mach_vm.h>
-#include <stddef.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/memory/shared_memory_helper.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/scoped_generic.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/threading/thread_restrictions.h"
-#include "build/build_config.h"
-
-#if defined(OS_MACOSX)
-#include "base/mac/foundation_util.h"
-#endif  // OS_MACOSX
-
-namespace base {
-
-namespace {
-
-// 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())
-    return false;
-
-  size_t size;
-  CHECK(handle.GetSize(&size));
-
-  // Map if necessary.
-  void* temp_addr = mapped_addr;
-  base::mac::ScopedMachVM scoper;
-  if (!temp_addr) {
-    // Intentionally lower current prot and max prot to |VM_PROT_READ|.
-    kern_return_t kr = mach_vm_map(
-        mach_task_self(), reinterpret_cast<mach_vm_address_t*>(&temp_addr),
-        size, 0, VM_FLAGS_ANYWHERE, handle.GetMemoryObject(), 0, FALSE,
-        VM_PROT_READ, VM_PROT_READ, VM_INHERIT_NONE);
-    if (kr != KERN_SUCCESS)
-      return false;
-    scoper.reset(reinterpret_cast<vm_address_t>(temp_addr),
-                 mach_vm_round_page(size));
-  }
-
-  // Make new memory object.
-  mach_port_t named_right;
-  kern_return_t kr = mach_make_memory_entry_64(
-      mach_task_self(), reinterpret_cast<memory_object_size_t*>(&size),
-      reinterpret_cast<memory_object_offset_t>(temp_addr), VM_PROT_READ,
-      &named_right, MACH_PORT_NULL);
-  if (kr != KERN_SUCCESS)
-    return false;
-
-  *new_handle = SharedMemoryHandle(named_right, size, base::GetCurrentProcId());
-  return true;
-}
-
-
-}  // namespace
-
-SharedMemory::SharedMemory()
-    : mapped_memory_mechanism_(SharedMemoryHandle::MACH),
-      readonly_mapped_file_(-1),
-      mapped_size_(0),
-      memory_(NULL),
-      read_only_(false),
-      requested_size_(0) {}
-
-SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
-    : shm_(handle),
-      mapped_memory_mechanism_(SharedMemoryHandle::POSIX),
-      readonly_mapped_file_(-1),
-      mapped_size_(0),
-      memory_(NULL),
-      read_only_(read_only),
-      requested_size_(0) {}
-
-SharedMemory::~SharedMemory() {
-  Unmap();
-  Close();
-}
-
-// static
-bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
-  return handle.IsValid();
-}
-
-// static
-SharedMemoryHandle SharedMemory::NULLHandle() {
-  return SharedMemoryHandle();
-}
-
-// static
-void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
-  handle.Close();
-}
-
-// static
-size_t SharedMemory::GetHandleLimit() {
-  return GetMaxFds();
-}
-
-// static
-SharedMemoryHandle SharedMemory::DuplicateHandle(
-    const SharedMemoryHandle& handle) {
-  return handle.Duplicate();
-}
-
-// static
-int SharedMemory::GetFdFromSharedMemoryHandle(
-    const SharedMemoryHandle& handle) {
-  return handle.file_descriptor_.fd;
-}
-
-bool SharedMemory::CreateAndMapAnonymous(size_t size) {
-  return CreateAnonymous(size) && 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) {
-  DCHECK(!shm_.IsValid());
-  if (options.size == 0) return false;
-
-  if (options.size > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return false;
-
-  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;
-
-  ScopedFILE fp;
-  ScopedFD readonly_fd;
-
-  FilePath path;
-  bool result = CreateAnonymousSharedMemory(options, &fp, &readonly_fd, &path);
-  if (!result)
-    return false;
-
-  if (!fp) {
-    PLOG(ERROR) << "Creating shared memory in " << path.value() << " failed";
-    return false;
-  }
-
-  // Get current size.
-  struct stat stat;
-  if (fstat(fileno(fp.get()), &stat) != 0)
-    return false;
-  const size_t current_size = stat.st_size;
-  if (current_size != options.size) {
-    if (HANDLE_EINTR(ftruncate(fileno(fp.get()), options.size)) != 0)
-      return false;
-  }
-  requested_size_ = options.size;
-
-  int mapped_file = -1;
-  result = PrepareMapFile(std::move(fp), std::move(readonly_fd), &mapped_file,
-                          &readonly_mapped_file_);
-
-  shm_ = SharedMemoryHandle(FileDescriptor(mapped_file, false));
-  return result;
-}
-
-bool SharedMemory::MapAt(off_t offset, size_t bytes) {
-  if (!shm_.IsValid())
-    return false;
-  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
-    return false;
-  if (memory_)
-    return false;
-
-  bool success = shm_.MapAt(offset, bytes, &memory_, read_only_);
-  if (success) {
-    mapped_size_ = bytes;
-    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
-                      (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
-    mapped_memory_mechanism_ = shm_.type_;
-  } else {
-    memory_ = NULL;
-  }
-
-  return success;
-}
-
-bool SharedMemory::Unmap() {
-  if (memory_ == NULL)
-    return false;
-
-  switch (mapped_memory_mechanism_) {
-    case SharedMemoryHandle::POSIX:
-      munmap(memory_, mapped_size_);
-      break;
-    case SharedMemoryHandle::MACH:
-      mach_vm_deallocate(mach_task_self(),
-                         reinterpret_cast<mach_vm_address_t>(memory_),
-                         mapped_size_);
-      break;
-  }
-
-  memory_ = NULL;
-  mapped_size_ = 0;
-  return true;
-}
-
-SharedMemoryHandle SharedMemory::handle() const {
-  switch (shm_.type_) {
-    case SharedMemoryHandle::POSIX:
-      return SharedMemoryHandle(
-          FileDescriptor(shm_.file_descriptor_.fd, false));
-    case SharedMemoryHandle::MACH:
-      return shm_;
-  }
-}
-
-SharedMemoryHandle SharedMemory::TakeHandle() {
-  SharedMemoryHandle dup = DuplicateHandle(handle());
-  Close();
-  return dup;
-}
-
-void SharedMemory::Close() {
-  shm_.Close();
-  shm_ = SharedMemoryHandle();
-  if (shm_.type_ == SharedMemoryHandle::POSIX) {
-    if (readonly_mapped_file_ > 0) {
-      if (IGNORE_EINTR(close(readonly_mapped_file_)) < 0)
-        PLOG(ERROR) << "close";
-      readonly_mapped_file_ = -1;
-    }
-  }
-}
-
-bool SharedMemory::Share(SharedMemoryHandle* new_handle, ShareMode share_mode) {
-  if (shm_.type_ == SharedMemoryHandle::MACH) {
-    DCHECK(shm_.IsValid());
-
-    bool success = false;
-    switch (share_mode) {
-      case SHARE_CURRENT_MODE:
-        *new_handle = shm_.Duplicate();
-        success = true;
-        break;
-      case SHARE_READONLY:
-        success = MakeMachSharedMemoryHandleReadOnly(new_handle, shm_, memory_);
-        break;
-    }
-
-    if (success)
-      new_handle->SetOwnershipPassesToIPC(true);
-
-    return success;
-  }
-
-  int handle_to_dup = -1;
-  switch (share_mode) {
-    case SHARE_CURRENT_MODE:
-      handle_to_dup = shm_.file_descriptor_.fd;
-      break;
-    case SHARE_READONLY:
-      // We could imagine re-opening the file from /dev/fd, but that can't make
-      // it readonly on Mac: https://codereview.chromium.org/27265002/#msg10
-      CHECK_GE(readonly_mapped_file_, 0);
-      handle_to_dup = readonly_mapped_file_;
-      break;
-  }
-
-  const int new_fd = HANDLE_EINTR(dup(handle_to_dup));
-  if (new_fd < 0) {
-    DPLOG(ERROR) << "dup() failed.";
-    return false;
-  }
-
-  new_handle->file_descriptor_.fd = new_fd;
-  new_handle->type_ = SharedMemoryHandle::POSIX;
-
-  return true;
-}
-
-bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
-                                        SharedMemoryHandle* new_handle,
-                                        bool close_self,
-                                        ShareMode share_mode) {
-  ALLOW_UNUSED_PARAM(process);
-  bool success = Share(new_handle, share_mode);
-  if (close_self) {
-    Unmap();
-    Close();
-  }
-  return success;
-}
-
-}  // namespace base
diff --git a/base/memory/shared_memory_mac_unittest.cc b/base/memory/shared_memory_mac_unittest.cc
deleted file mode 100644
index 4ccee89deb..0000000000
--- a/base/memory/shared_memory_mac_unittest.cc
+++ /dev/null
@@ -1,459 +0,0 @@
-// Copyright 2015 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 <mach/mach.h>
-#include <mach/mach_vm.h>
-#include <servers/bootstrap.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/command_line.h"
-#include "base/mac/mac_util.h"
-#include "base/mac/mach_logging.h"
-#include "base/mac/scoped_mach_port.h"
-#include "base/macros.h"
-#include "base/memory/shared_memory.h"
-#include "base/process/process_handle.h"
-#include "base/rand_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/sys_info.h"
-#include "base/test/multiprocess_test.h"
-#include "base/test/test_timeouts.h"
-#include "testing/multiprocess_func_list.h"
-
-namespace base {
-
-namespace {
-
-// Gets the current and maximum protection levels of the memory region.
-// Returns whether the operation was successful.
-// |current| and |max| are output variables only populated on success.
-bool GetProtections(void* address, size_t size, int* current, int* max) {
-  vm_region_info_t region_info;
-  mach_vm_address_t mem_address = reinterpret_cast<mach_vm_address_t>(address);
-  mach_vm_size_t mem_size = size;
-  vm_region_basic_info_64 basic_info;
-
-  region_info = reinterpret_cast<vm_region_recurse_info_t>(&basic_info);
-  vm_region_flavor_t flavor = VM_REGION_BASIC_INFO_64;
-  memory_object_name_t memory_object;
-  mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT_64;
-
-  kern_return_t kr =
-      mach_vm_region(mach_task_self(), &mem_address, &mem_size, flavor,
-                     region_info, &count, &memory_object);
-  if (kr != KERN_SUCCESS) {
-    MACH_LOG(ERROR, kr) << "Failed to get region info.";
-    return false;
-  }
-
-  *current = basic_info.protection;
-  *max = basic_info.max_protection;
-  return true;
-}
-
-// Creates a new SharedMemory with the given |size|, filled with 'a'.
-std::unique_ptr<SharedMemory> CreateSharedMemory(int size) {
-  SharedMemoryHandle shm(size);
-  if (!shm.IsValid()) {
-    LOG(ERROR) << "Failed to make SharedMemoryHandle";
-    return nullptr;
-  }
-  std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
-  shared_memory->Map(size);
-  memset(shared_memory->memory(), 'a', size);
-  return shared_memory;
-}
-
-static const std::string g_service_switch_name = "service_name";
-
-// Structs used to pass a mach port from client to server.
-struct MachSendPortMessage {
-  mach_msg_header_t header;
-  mach_msg_body_t body;
-  mach_msg_port_descriptor_t data;
-};
-struct MachReceivePortMessage {
-  mach_msg_header_t header;
-  mach_msg_body_t body;
-  mach_msg_port_descriptor_t data;
-  mach_msg_trailer_t trailer;
-};
-
-// Makes the current process into a Mach Server with the given |service_name|.
-mach_port_t BecomeMachServer(const char* service_name) {
-  mach_port_t port;
-  kern_return_t kr = bootstrap_check_in(bootstrap_port, service_name, &port);
-  MACH_CHECK(kr == KERN_SUCCESS, kr) << "BecomeMachServer";
-  return port;
-}
-
-// Returns the mach port for the Mach Server with the given |service_name|.
-mach_port_t LookupServer(const char* service_name) {
-  mach_port_t server_port;
-  kern_return_t kr =
-      bootstrap_look_up(bootstrap_port, service_name, &server_port);
-  MACH_CHECK(kr == KERN_SUCCESS, kr) << "LookupServer";
-  return server_port;
-}
-
-mach_port_t MakeReceivingPort() {
-  mach_port_t client_port;
-  kern_return_t kr =
-      mach_port_allocate(mach_task_self(),         // our task is acquiring
-                         MACH_PORT_RIGHT_RECEIVE,  // a new receive right
-                         &client_port);            // with this name
-  MACH_CHECK(kr == KERN_SUCCESS, kr) << "MakeReceivingPort";
-  return client_port;
-}
-
-// Blocks until a mach message is sent to |server_port|. This mach message
-// must contain a mach port. Returns that mach port.
-mach_port_t ReceiveMachPort(mach_port_t port_to_listen_on) {
-  MachReceivePortMessage recv_msg;
-  mach_msg_header_t* recv_hdr = &(recv_msg.header);
-  recv_hdr->msgh_local_port = port_to_listen_on;
-  recv_hdr->msgh_size = sizeof(recv_msg);
-  kern_return_t kr =
-      mach_msg(recv_hdr,               // message buffer
-               MACH_RCV_MSG,           // option indicating service
-               0,                      // send size
-               recv_hdr->msgh_size,    // size of header + body
-               port_to_listen_on,      // receive name
-               MACH_MSG_TIMEOUT_NONE,  // no timeout, wait forever
-               MACH_PORT_NULL);        // no notification port
-  MACH_CHECK(kr == KERN_SUCCESS, kr) << "ReceiveMachPort";
-  mach_port_t other_task_port = recv_msg.data.name;
-  return other_task_port;
-}
-
-// Passes a copy of the send right of |port_to_send| to |receiving_port|.
-void SendMachPort(mach_port_t receiving_port,
-                  mach_port_t port_to_send,
-                  int disposition) {
-  MachSendPortMessage send_msg;
-  mach_msg_header_t* send_hdr;
-  send_hdr = &(send_msg.header);
-  send_hdr->msgh_bits =
-      MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) | MACH_MSGH_BITS_COMPLEX;
-  send_hdr->msgh_size = sizeof(send_msg);
-  send_hdr->msgh_remote_port = receiving_port;
-  send_hdr->msgh_local_port = MACH_PORT_NULL;
-  send_hdr->msgh_reserved = 0;
-  send_hdr->msgh_id = 0;
-  send_msg.body.msgh_descriptor_count = 1;
-  send_msg.data.name = port_to_send;
-  send_msg.data.disposition = disposition;
-  send_msg.data.type = MACH_MSG_PORT_DESCRIPTOR;
-  int kr = mach_msg(send_hdr,               // message buffer
-                    MACH_SEND_MSG,          // option indicating send
-                    send_hdr->msgh_size,    // size of header + body
-                    0,                      // receive limit
-                    MACH_PORT_NULL,         // receive name
-                    MACH_MSG_TIMEOUT_NONE,  // no timeout, wait forever
-                    MACH_PORT_NULL);        // no notification port
-  MACH_CHECK(kr == KERN_SUCCESS, kr) << "SendMachPort";
-}
-
-std::string CreateRandomServiceName() {
-  return StringPrintf("SharedMemoryMacMultiProcessTest.%llu", RandUint64());
-}
-
-// Sets up the mach communication ports with the server. Returns a port to which
-// the server will send mach objects.
-mach_port_t CommonChildProcessSetUp() {
-  CommandLine cmd_line = *CommandLine::ForCurrentProcess();
-  std::string service_name =
-      cmd_line.GetSwitchValueASCII(g_service_switch_name);
-  mac::ScopedMachSendRight server_port(LookupServer(service_name.c_str()));
-  mach_port_t client_port = MakeReceivingPort();
-
-  // Send the port that this process is listening on to the server.
-  SendMachPort(server_port.get(), client_port, MACH_MSG_TYPE_MAKE_SEND);
-  return client_port;
-}
-
-// The number of active names in the current task's port name space.
-mach_msg_type_number_t GetActiveNameCount() {
-  mach_port_name_array_t name_array;
-  mach_msg_type_number_t names_count;
-  mach_port_type_array_t type_array;
-  mach_msg_type_number_t types_count;
-  kern_return_t kr = mach_port_names(mach_task_self(), &name_array,
-                                     &names_count, &type_array, &types_count);
-  MACH_CHECK(kr == KERN_SUCCESS, kr) << "GetActiveNameCount";
-  return names_count;
-}
-
-}  // namespace
-
-class SharedMemoryMacMultiProcessTest : public MultiProcessTest {
- public:
-  SharedMemoryMacMultiProcessTest() {}
-
-  CommandLine MakeCmdLine(const std::string& procname) override {
-    CommandLine command_line = MultiProcessTest::MakeCmdLine(procname);
-    // Pass the service name to the child process.
-    command_line.AppendSwitchASCII(g_service_switch_name, service_name_);
-    return command_line;
-  }
-
-  void SetUpChild(const std::string& name) {
-    // Make a random service name so that this test doesn't conflict with other
-    // similar tests.
-    service_name_ = CreateRandomServiceName();
-    server_port_.reset(BecomeMachServer(service_name_.c_str()));
-    spawn_child_ = SpawnChild(name);
-    client_port_.reset(ReceiveMachPort(server_port_.get()));
-  }
-
-  static const int s_memory_size = 99999;
-
- protected:
-  std::string service_name_;
-
-  // A port on which the main process listens for mach messages from the child
-  // process.
-  mac::ScopedMachReceiveRight server_port_;
-
-  // A port on which the child process listens for mach messages from the main
-  // process.
-  mac::ScopedMachSendRight client_port_;
-
-  base::SpawnChildResult spawn_child_;
-  DISALLOW_COPY_AND_ASSIGN(SharedMemoryMacMultiProcessTest);
-};
-
-// Tests that content written to shared memory in the server process can be read
-// by the child process.
-TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemory) {
-  SetUpChild("MachBasedSharedMemoryClient");
-
-  std::unique_ptr<SharedMemory> shared_memory(
-      CreateSharedMemory(s_memory_size));
-
-  // Send the underlying memory object to the client process.
-  SendMachPort(client_port_.get(), shared_memory->handle().GetMemoryObject(),
-               MACH_MSG_TYPE_COPY_SEND);
-  int rv = -1;
-  ASSERT_TRUE(spawn_child_.process.WaitForExitWithTimeout(
-      TestTimeouts::action_timeout(), &rv));
-  EXPECT_EQ(0, rv);
-}
-
-MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryClient) {
-  mac::ScopedMachReceiveRight client_port(CommonChildProcessSetUp());
-  // The next mach port should be for a memory object.
-  mach_port_t memory_object = ReceiveMachPort(client_port.get());
-  SharedMemoryHandle shm(memory_object,
-                         SharedMemoryMacMultiProcessTest::s_memory_size,
-                         GetCurrentProcId());
-  SharedMemory shared_memory(shm, false);
-  shared_memory.Map(SharedMemoryMacMultiProcessTest::s_memory_size);
-  const char* start = static_cast<const char*>(shared_memory.memory());
-  for (int i = 0; i < SharedMemoryMacMultiProcessTest::s_memory_size; ++i) {
-    DCHECK_EQ(start[i], 'a');
-  }
-  return 0;
-}
-
-// Tests that mapping shared memory with an offset works correctly.
-TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemoryWithOffset) {
-  SetUpChild("MachBasedSharedMemoryWithOffsetClient");
-
-  SharedMemoryHandle shm(s_memory_size);
-  ASSERT_TRUE(shm.IsValid());
-  SharedMemory shared_memory(shm, false);
-  shared_memory.Map(s_memory_size);
-
-  size_t page_size = SysInfo::VMAllocationGranularity();
-  char* start = static_cast<char*>(shared_memory.memory());
-  memset(start, 'a', page_size);
-  memset(start + page_size, 'b', page_size);
-  memset(start + 2 * page_size, 'c', page_size);
-
-  // Send the underlying memory object to the client process.
-  SendMachPort(
-      client_port_.get(), shm.GetMemoryObject(), MACH_MSG_TYPE_COPY_SEND);
-  int rv = -1;
-  ASSERT_TRUE(spawn_child_.process.WaitForExitWithTimeout(
-      TestTimeouts::action_timeout(), &rv));
-  EXPECT_EQ(0, rv);
-}
-
-MULTIPROCESS_TEST_MAIN(MachBasedSharedMemoryWithOffsetClient) {
-  mac::ScopedMachReceiveRight client_port(CommonChildProcessSetUp());
-  // The next mach port should be for a memory object.
-  mach_port_t memory_object = ReceiveMachPort(client_port.get());
-  SharedMemoryHandle shm(memory_object,
-                         SharedMemoryMacMultiProcessTest::s_memory_size,
-                         GetCurrentProcId());
-  SharedMemory shared_memory(shm, false);
-  size_t page_size = SysInfo::VMAllocationGranularity();
-  shared_memory.MapAt(page_size, 2 * page_size);
-  const char* start = static_cast<const char*>(shared_memory.memory());
-  for (size_t i = 0; i < page_size; ++i) {
-    DCHECK_EQ(start[i], 'b');
-  }
-  for (size_t i = page_size; i < 2 * page_size; ++i) {
-    DCHECK_EQ(start[i], 'c');
-  }
-  return 0;
-}
-
-// Tests that duplication and closing has the right effect on Mach reference
-// counts.
-TEST_F(SharedMemoryMacMultiProcessTest, MachDuplicateAndClose) {
-  mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
-  // Making a new SharedMemoryHandle increments the name count.
-  SharedMemoryHandle shm(s_memory_size);
-  ASSERT_TRUE(shm.IsValid());
-  EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
-  // Duplicating the SharedMemoryHandle increments the ref count, but doesn't
-  // make a new name.
-  shm.Duplicate();
-  EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
-  // Closing the SharedMemoryHandle decrements the ref count. The first time has
-  // no effect.
-  shm.Close();
-  EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
-  // Closing the SharedMemoryHandle decrements the ref count. The second time
-  // destroys the port.
-  shm.Close();
-  EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-// Tests that Mach shared memory can be mapped and unmapped.
-TEST_F(SharedMemoryMacMultiProcessTest, MachUnmapMap) {
-  mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
-  std::unique_ptr<SharedMemory> shared_memory =
-      CreateSharedMemory(s_memory_size);
-  ASSERT_TRUE(shared_memory->Unmap());
-  ASSERT_TRUE(shared_memory->Map(s_memory_size));
-  shared_memory.reset();
-  EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-// Tests that passing a SharedMemoryHandle to a SharedMemory object also passes
-// ownership, and that destroying the SharedMemory closes the SharedMemoryHandle
-// as well.
-TEST_F(SharedMemoryMacMultiProcessTest, MachSharedMemoryTakesOwnership) {
-  mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
-  // Making a new SharedMemoryHandle increments the name count.
-  SharedMemoryHandle shm(s_memory_size);
-  ASSERT_TRUE(shm.IsValid());
-  EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
-  // Name count doesn't change when mapping the memory.
-  std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false));
-  shared_memory->Map(s_memory_size);
-  EXPECT_EQ(active_name_count + 1, GetActiveNameCount());
-
-  // Destroying the SharedMemory object frees the resource.
-  shared_memory.reset();
-  EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-// Tests that the read-only flag works.
-TEST_F(SharedMemoryMacMultiProcessTest, MachReadOnly) {
-  std::unique_ptr<SharedMemory> shared_memory(
-      CreateSharedMemory(s_memory_size));
-
-  SharedMemoryHandle shm2 = shared_memory->handle().Duplicate();
-  ASSERT_TRUE(shm2.IsValid());
-  SharedMemory shared_memory2(shm2, true);
-  shared_memory2.Map(s_memory_size);
-  ASSERT_DEATH(memset(shared_memory2.memory(), 'b', s_memory_size), "");
-}
-
-// Tests that the method ShareToProcess() works.
-TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcess) {
-  mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
-  {
-    std::unique_ptr<SharedMemory> shared_memory(
-        CreateSharedMemory(s_memory_size));
-
-    SharedMemoryHandle shm2;
-    ASSERT_TRUE(shared_memory->ShareToProcess(GetCurrentProcId(), &shm2));
-    ASSERT_TRUE(shm2.IsValid());
-    SharedMemory shared_memory2(shm2, true);
-    shared_memory2.Map(s_memory_size);
-
-    ASSERT_EQ(0, memcmp(shared_memory->memory(), shared_memory2.memory(),
-                        s_memory_size));
-  }
-
-  EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-// Tests that the method ShareReadOnlyToProcess() creates a memory object that
-// is read only.
-TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcessReadonly) {
-  std::unique_ptr<SharedMemory> shared_memory(
-      CreateSharedMemory(s_memory_size));
-
-  // Check the protection levels.
-  int current_prot, max_prot;
-  ASSERT_TRUE(GetProtections(shared_memory->memory(),
-                             shared_memory->mapped_size(), &current_prot,
-                             &max_prot));
-  ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, current_prot);
-  ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, max_prot);
-
-  // Make a new memory object.
-  SharedMemoryHandle shm2;
-  ASSERT_TRUE(shared_memory->ShareReadOnlyToProcess(GetCurrentProcId(), &shm2));
-  ASSERT_TRUE(shm2.IsValid());
-
-  // Mapping with |readonly| set to |false| should fail.
-  SharedMemory shared_memory2(shm2, false);
-  shared_memory2.Map(s_memory_size);
-  ASSERT_EQ(nullptr, shared_memory2.memory());
-
-  // Now trying mapping with |readonly| set to |true|.
-  SharedMemory shared_memory3(shm2.Duplicate(), true);
-  shared_memory3.Map(s_memory_size);
-  ASSERT_NE(nullptr, shared_memory3.memory());
-
-  // Check the protection levels.
-  ASSERT_TRUE(GetProtections(shared_memory3.memory(),
-                             shared_memory3.mapped_size(), &current_prot,
-                             &max_prot));
-  ASSERT_EQ(VM_PROT_READ, current_prot);
-  ASSERT_EQ(VM_PROT_READ, max_prot);
-
-  // The memory should still be readonly, since the underlying memory object
-  // is readonly.
-  ASSERT_DEATH(memset(shared_memory2.memory(), 'b', s_memory_size), "");
-}
-
-// Tests that the method ShareReadOnlyToProcess() doesn't leak.
-TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcessReadonlyLeak) {
-  mach_msg_type_number_t active_name_count = GetActiveNameCount();
-
-  {
-    std::unique_ptr<SharedMemory> shared_memory(
-        CreateSharedMemory(s_memory_size));
-
-    SharedMemoryHandle shm2;
-    ASSERT_TRUE(
-        shared_memory->ShareReadOnlyToProcess(GetCurrentProcId(), &shm2));
-    ASSERT_TRUE(shm2.IsValid());
-
-    // Intentionally map with |readonly| set to |false|.
-    SharedMemory shared_memory2(shm2, false);
-    shared_memory2.Map(s_memory_size);
-  }
-
-  EXPECT_EQ(active_name_count, GetActiveNameCount());
-}
-
-}  //  namespace base