Make SharedMemoryHandle a class on Mac.

base/memory/shared_memory_handle_mac.cc

Index: base/memory/shared_memory_handle_mac.cc
diff --git a/base/memory/shared_memory_handle_mac.cc b/base/memory/shared_memory_handle_mac.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4dfb44331d7555bb4e5e5b0eca434186e7d92532
--- /dev/null
+++ b/base/memory/shared_memory_handle_mac.cc
@@ -0,0 +1,100 @@
+// 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 <unistd.h>
+
+#include "base/pickle.h"
+#include "base/posix/eintr_wrapper.h"
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+namespace base {
+
+SharedMemoryHandle::SharedMemoryHandle()
+    : mechanism_(POSIX), file_descriptor_() {
+}
+
+SharedMemoryHandle::SharedMemoryHandle(const FileDescriptor& file_descriptor)
+    : mechanism_(POSIX), file_descriptor_(file_descriptor) {
+}
+
+SharedMemoryHandle::SharedMemoryHandle(int fd, bool auto_close)
+    : mechanism_(POSIX), file_descriptor_(fd, auto_close) {
+}
+
+SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle)
+    : mechanism_(handle.mechanism_), file_descriptor_(handle.file_descriptor_) {
+}
+
+SharedMemoryHandle& SharedMemoryHandle::operator=(
+    const SharedMemoryHandle& handle) {
+  mechanism_ = handle.mechanism_;
+  file_descriptor_ = handle.file_descriptor_;
+  return *this;
+}
+
+bool SharedMemoryHandle::operator==(const SharedMemoryHandle& handle) const {
+  return mechanism_ == handle.mechanism_ &&
+         file_descriptor_ == handle.file_descriptor_;
+}
+
+bool SharedMemoryHandle::operator!=(const SharedMemoryHandle& handle) const {
+  return !operator==(handle);
+}
+
+void SharedMemoryHandle::WriteMechanismToPickle(Pickle* pickle) const {
+  pickle->WriteInt(mechanism_);
+}
+
+bool SharedMemoryHandle::ReadMechanismFromPickle(PickleIterator* iterator) {
+  int mechanism;
+  if (!iterator->ReadInt(&mechanism))
+    return false;
+
+  switch (mechanism) {
+    case POSIX:
+    case MACH:
+      mechanism_ = static_cast<Mechanism>(mechanism);
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool SharedMemoryHandle::IsBackedByPOSIXFd() const {
+  return mechanism_ == POSIX;
+}
+
+int SharedMemoryHandle::GetFileHandle() const {
+  CHECK_EQ(mechanism_, POSIX);

[Robert Sesek, 2015/06/15 21:34:33]

Can these be DCHECKs instead? This should only happen for developer error,
right?

[erikchen, 2015/06/16 00:59:27]

You're right, DCHECKs will work here.

+  return file_descriptor_.fd;
+}
+
+void SharedMemoryHandle::SetFileHandle(int fd, bool auto_close) {
+  CHECK_EQ(mechanism_, POSIX);
+  file_descriptor_.fd = fd;
+  file_descriptor_.auto_close = auto_close;
+}
+
+FileDescriptor* SharedMemoryHandle::GetFileDescriptor() {
+  CHECK_EQ(mechanism_, POSIX);
+  return &file_descriptor_;
+}
+
+const FileDescriptor* SharedMemoryHandle::GetFileDescriptor() const {
+  CHECK_EQ(mechanism_, POSIX);
+  return &file_descriptor_;
+}
+
+SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
+  CHECK_EQ(mechanism_, POSIX);
+  int duped_handle = HANDLE_EINTR(dup(file_descriptor_.fd));
+  if (duped_handle < 0)
+    return SharedMemoryHandle();
+  return SharedMemoryHandle(duped_handle, true);
+}
+
+}  // namespace base
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)