Add a size parameter to SharedMemoryHandle.

ipc/ipc_message_utils.cc

Index: ipc/ipc_message_utils.cc
diff --git a/ipc/ipc_message_utils.cc b/ipc/ipc_message_utils.cc
index e8aeee4bda4343ce5055e781136b2537ac61bd71..8179cd4dfb2adcab8a92a84ded845df2f9b784eb 100644
--- a/ipc/ipc_message_utils.cc
+++ b/ipc/ipc_message_utils.cc
@@ -621,7 +621,7 @@ void ParamTraits<base::FileDescriptor>::GetSize(base::PickleSizer* sizer,
 void ParamTraits<base::FileDescriptor>::Write(base::Pickle* m,
                                               const param_type& p) {
   // This serialization must be kept in sync with
-  // nacl_ipc_adapater.cc:WriteHandle().
+  // nacl_message_scanner.cc:WriteHandle().
   const bool valid = p.fd >= 0;
   WriteParam(m, valid);
 
@@ -676,158 +676,41 @@ void ParamTraits<base::FileDescriptor>::Log(const param_type& p,
 }
 #endif  // defined(OS_POSIX)
 
-#if defined(OS_MACOSX) && !defined(OS_IOS)
 void ParamTraits<base::SharedMemoryHandle>::GetSize(base::PickleSizer* sizer,
                                                     const param_type& p) {
   GetParamSize(sizer, p.IsValid());
-  if (p.IsValid()) {
-    GetParamSize(sizer, p.GetMemoryObject());
-    GetParamSize(sizer, p.GetGUID());
-    uint32_t dummy = 0;
-    GetParamSize(sizer, dummy);
-  }
-}
-
-void ParamTraits<base::SharedMemoryHandle>::Write(base::Pickle* m,
-                                                  const param_type& p) {
-  const bool valid = p.IsValid();
-  WriteParam(m, valid);
-
-  if (!valid)
+  if (!p.IsValid())
     return;
 
-  MachPortMac mach_port_mac(p.GetMemoryObject());
-  WriteParam(m, mach_port_mac);
-  DCHECK(!p.GetGUID().is_empty());
-  WriteParam(m, p.GetGUID());
-
-  size_t size = 0;
-  bool result = p.GetSize(&size);
-  DCHECK(result);
-  ParamTraits<uint32_t>::Write(m, static_cast<uint32_t>(size));
-
-  // If the caller intended to pass ownership to the IPC stack, release a
-  // reference.
-  if (p.OwnershipPassesToIPC())
-    p.Close();
-}
-
-bool ParamTraits<base::SharedMemoryHandle>::Read(const base::Pickle* m,
-                                                 base::PickleIterator* iter,
-                                                 param_type* r) {
-  *r = base::SharedMemoryHandle();
-
-  bool valid;
-  if (!ReadParam(m, iter, &valid))
-    return false;
-  if (!valid)
-    return true;
-
-  MachPortMac mach_port_mac;
-  if (!ReadParam(m, iter, &mach_port_mac))
-    return false;
-
-  base::UnguessableToken guid;
-  if (!ReadParam(m, iter, &guid))
-    return false;
-
-  uint32_t size;
-  if (!ParamTraits<uint32_t>::Read(m, iter, &size))
-    return false;
-
-  *r = base::SharedMemoryHandle(mach_port_mac.get_mach_port(),
-                                static_cast<size_t>(size), guid);
-  return true;
-}
-
-void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
-                                                std::string* l) {
-  l->append("Mach port: ");
-  LogParam(p.GetMemoryObject(), l);
-  l->append("GUID: ");
-  ParamTraits<base::UnguessableToken>::Log(p.GetGUID(), l);
-}
-
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  GetParamSize(sizer, p.GetMemoryObject());
 #elif defined(OS_WIN)
-void ParamTraits<base::SharedMemoryHandle>::GetSize(base::PickleSizer* s,
-                                                    const param_type& p) {
-  GetParamSize(s, p.IsValid());
-  if (p.IsValid()) {
-    GetParamSize(s, p.GetHandle());
-    GetParamSize(s, p.GetGUID());
-  }
-}
-
-void ParamTraits<base::SharedMemoryHandle>::Write(base::Pickle* m,
-                                                  const param_type& p) {
-  const bool valid = p.IsValid();
-  WriteParam(m, valid);
-
-  if (!valid)
-    return;
-
-  HandleWin handle_win(p.GetHandle(), HandleWin::DUPLICATE);
-  WriteParam(m, handle_win);
-
-  // If the caller intended to pass ownership to the IPC stack, release a
-  // reference.
-  if (p.OwnershipPassesToIPC())
-    p.Close();
-
-  DCHECK(!p.GetGUID().is_empty());
-  WriteParam(m, p.GetGUID());
-}
-
-bool ParamTraits<base::SharedMemoryHandle>::Read(const base::Pickle* m,
-                                                 base::PickleIterator* iter,
-                                                 param_type* r) {
-  *r = base::SharedMemoryHandle();
-
-  bool valid;
-  if (!ReadParam(m, iter, &valid))
-    return false;
-  if (!valid)
-    return true;
-
-  HandleWin handle_win;
-  if (!ReadParam(m, iter, &handle_win))
-    return false;
-
-  base::UnguessableToken guid;
-  if (!ReadParam(m, iter, &guid))
-    return false;
-
-  *r = base::SharedMemoryHandle(handle_win.get_handle(), guid);
-  return true;
-}
+  GetParamSize(sizer, p.GetHandle());
+#else
+  sizer->AddAttachment();
+#endif
 
-void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
-                                                std::string* l) {
-  l->append("HANDLE: ");
-  LogParam(p.GetHandle(), l);
-  l->append("GUID: ");
-  ParamTraits<base::UnguessableToken>::Log(p.GetGUID(), l);
-}
-#elif defined(OS_POSIX)
-void ParamTraits<base::SharedMemoryHandle>::GetSize(base::PickleSizer* sizer,
-                                                    const param_type& p) {
-  GetParamSize(sizer, p.IsValid());
-  if (p.IsValid()) {
-    sizer->AddAttachment();
-    GetParamSize(sizer, p.GetGUID());
-  }
+  GetParamSize(sizer, p.GetGUID());
+  GetParamSize(sizer, static_cast<uint64_t>(p.GetSize()));
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Write(base::Pickle* m,
                                                   const param_type& p) {
   // This serialization must be kept in sync with
-  // nacl_ipc_adapater.cc:WriteHandle().
+  // nacl_message_scanner.cc:WriteHandle().
   const bool valid = p.IsValid();
   WriteParam(m, valid);
 
   if (!valid)
     return;
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  MachPortMac mach_port_mac(p.GetMemoryObject());
+  WriteParam(m, mach_port_mac);
+#elif defined(OS_WIN)
+  HandleWin handle_win(p.GetHandle(), HandleWin::DUPLICATE);
+  WriteParam(m, handle_win);
+#else
   if (p.OwnershipPassesToIPC()) {
     if (!m->WriteAttachment(new internal::PlatformFileAttachment(
             base::ScopedFD(p.GetHandle()))))
@@ -837,8 +720,18 @@ void ParamTraits<base::SharedMemoryHandle>::Write(base::Pickle* m,
             new internal::PlatformFileAttachment(p.GetHandle())))
       NOTREACHED();
   }
+#endif
+
+#if (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_WIN)
+  // If the caller intended to pass ownership to the IPC stack, release a
+  // reference.
+  if (p.OwnershipPassesToIPC())
+    p.Close();
+#endif
+
   DCHECK(!p.GetGUID().is_empty());
   WriteParam(m, p.GetGUID());
+  WriteParam(m, static_cast<uint64_t>(p.GetSize()));
 }
 
 bool ParamTraits<base::SharedMemoryHandle>::Read(const base::Pickle* m,
@@ -849,10 +742,18 @@ bool ParamTraits<base::SharedMemoryHandle>::Read(const base::Pickle* m,
   bool valid;
   if (!ReadParam(m, iter, &valid))
     return false;
-
   if (!valid)
     return true;
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  MachPortMac mach_port_mac;
+  if (!ReadParam(m, iter, &mach_port_mac))
+    return false;
+#elif defined(OS_WIN)
+  HandleWin handle_win;
+  if (!ReadParam(m, iter, &handle_win))
+    return false;
+#else
   scoped_refptr<base::Pickle::Attachment> attachment;
   if (!m->ReadAttachment(iter, &attachment))
     return false;
@@ -861,31 +762,50 @@ bool ParamTraits<base::SharedMemoryHandle>::Read(const base::Pickle* m,
       MessageAttachment::Type::PLATFORM_FILE) {
     return false;
   }
+#endif
 
   base::UnguessableToken guid;
-  if (!ReadParam(m, iter, &guid))
+  uint64_t size;
+  if (!ReadParam(m, iter, &guid) || !ReadParam(m, iter, &size)) {
     return false;
+  }
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  *r = base::SharedMemoryHandle(mach_port_mac.get_mach_port(),
+                                static_cast<size_t>(size), guid);
+#elif defined(OS_WIN)
+  *r = base::SharedMemoryHandle(handle_win.get_handle(),
+                                static_cast<size_t>(size), guid);
+#else
   *r = base::SharedMemoryHandle(
       base::FileDescriptor(
           static_cast<internal::PlatformFileAttachment*>(attachment.get())
               ->TakePlatformFile(),
           true),
-      guid);
+      static_cast<size_t>(size), guid);
+#endif
+
   return true;
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
                                                 std::string* l) {
-  if (p.OwnershipPassesToIPC()) {
-    l->append(base::StringPrintf("FD(%d auto-close)", p.GetHandle()));
-  } else {
-    l->append(base::StringPrintf("FD(%d)", p.GetHandle()));
-  }
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  l->append("Mach port: ");
+  LogParam(p.GetMemoryObject(), l);
+#elif defined(OS_WIN)
+  l->append("HANDLE: ");
+  LogParam(p.GetHandle(), l);
+#else
+  l->append("FD: ");
+  LogParam(p.GetHandle(), l);
+#endif
+
   l->append("GUID: ");
-  ParamTraits<base::UnguessableToken>::Log(p.GetGUID(), l);
+  LogParam(p.GetGUID(), l);
+  l->append("size: ");
+  LogParam(static_cast<uint64_t>(p.GetSize()), l);
 }
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
 #if defined(OS_WIN)
 void ParamTraits<PlatformFileForTransit>::GetSize(base::PickleSizer* s,
@@ -1143,7 +1063,7 @@ void ParamTraits<base::UnguessableToken>::Write(base::Pickle* m,
   DCHECK(!p.is_empty());
 
   // This serialization must be kept in sync with
-  // nacl_ipc_adapater.cc:WriteHandle().
+  // nacl_message_scanner.cc:WriteHandle().
   ParamTraits<uint64_t>::Write(m, p.GetHighForSerialization());
   ParamTraits<uint64_t>::Write(m, p.GetLowForSerialization());
 }