Make SharedMemoryHandle a class on Mac.

ipc/ipc_message_utils.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 "ipc/ipc_message_utils.h"
 
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/nullable_string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_message_attachment.h"
 #include "ipc/ipc_message_attachment_set.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+#include "base/memory/shared_memory_handle.h"
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
 #if defined(OS_WIN)
 #include <tchar.h>
 #endif
 
 namespace IPC {
 
 namespace {
 
 const int kMaxRecursionDepth = 100;
 
@@ skipping 476 matching lines @@
 void ParamTraits<base::FileDescriptor>::Log(const param_type& p,
                                             std::string* l) {
   if (p.auto_close) {
     l->append(base::StringPrintf("FD(%d auto-close)", p.fd));
   } else {
     l->append(base::StringPrintf("FD(%d)", p.fd));
   }
 }
 #endif  // defined(OS_POSIX)
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+void ParamTraits<base::SharedMemoryHandle>::Write(Message* m,
+                                                  const param_type& p) {
+  p.WriteMechanismToPickle(m);
+
+  if (p.IsBackedByPOSIXFd())
+    ParamTraits<base::FileDescriptor>::Write(m, *p.GetFileDescriptor());

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

Hm… looking at this again, it's a bit odd to have things partially serialized in
//base and partially in //ipc. Maybe we merge your original approach and what I
suggested last round:

Add SharedMemoryHandle::GetType() rather than having IsBackedByPOSIXFD() (and
presumably IsBackedByMachObject()), but do the conversion to the wire format
here, rather than exposing an oddly named method on the //base interface. You
probably also want to static_assert<> that the enum type fits within the wire
type. That way all the serialization and deserialization logic is one place, and
it doesn't have to be directly exposed on the SharedMemoryHandle interface.

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

Added static asserts. Moved logic out of SharedMemoryHandle and into this class.

+}
+
+bool ParamTraits<base::SharedMemoryHandle>::Read(const Message* m,
+                                                 base::PickleIterator* iter,
+                                                 param_type* r) {
+  if (!r->ReadMechanismFromPickle(iter))
+    return false;
+
+  if (r->IsBackedByPOSIXFd()) {
+    return ParamTraits<base::FileDescriptor>::Read(m, iter,
+                                                   r->GetFileDescriptor());
+  }
+
+  return true;
+}
+
+void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
+                                                std::string* l) {
+  if (p.IsBackedByPOSIXFd()) {
+    l->append(base::StringPrintf("Mechanism POSIX Fd"));
+    ParamTraits<base::FileDescriptor>::Log(*p.GetFileDescriptor(), l);
+  }
+}
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
 void ParamTraits<base::FilePath>::Write(Message* m, const param_type& p) {
   p.WriteToPickle(m);
 }
 
 bool ParamTraits<base::FilePath>::Read(const Message* m,
                                        base::PickleIterator* iter,
                                        param_type* r) {
   return r->ReadFromPickle(iter);
 }
 
@@ skipping 337 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC