Add a GUID to base::SharedMemoryHandle.

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 <stddef.h>
 #include <stdint.h>
 
 #include "base/files/file_path.h"
@@ skipping 660 matching lines @@
   } else {
     l->append(base::StringPrintf("FD(%d)", p.fd));
   }
 }
 #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.GetMemoryObject());
-  uint32_t dummy = 0;
+  ParamTraits<base::UnguessableToken>::GetSize(sizer, p.GetGUID());
+
+  // Size of p.GetSize().
+  uint64_t dummy = 0;
+  static_assert(sizeof(dummy) == sizeof(size_t),
+                "The dummy size must match the size written in ::Write");
   GetParamSize(sizer, dummy);
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Write(base::Pickle* m,
                                                   const param_type& p) {
   MachPortMac mach_port_mac(p.GetMemoryObject());
   ParamTraits<MachPortMac>::Write(m, mach_port_mac);
+  ParamTraits<base::UnguessableToken>::Write(m, p.GetGUID());

[Will Harris, 2017/05/04 17:50:51]

should there be a DCHECK here that guid is not empty, to satisfy the comment in
unguessable_token.h "It is illegal to send empty UnguessableTokens across
processes"

[erikchen, 2017/05/04 19:21:13]

Yes, done.

+
   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) {
   MachPortMac mach_port_mac;
   if (!ParamTraits<MachPortMac>::Read(m, iter, &mach_port_mac))
     return false;
 
+  base::UnguessableToken guid;
+  if (!ParamTraits<base::UnguessableToken>::Read(m, iter, &guid))

[Ken Rockot(use gerrit already), 2017/05/04 17:54:50]

We have templated helper functions for this in ipc_message_util.h. You should be
able to e.g.:

 GetParamSize(size, p.GetGUID())
 ReadParam(m, iter, &guid)
 WriteParam(m, p.GetGUID())

with no need for explicit template arguments.

[erikchen, 2017/05/04 19:21:13]

Done.

+    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));
+                                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);
 }
 
 #elif defined(OS_WIN)
 void ParamTraits<base::SharedMemoryHandle>::GetSize(base::PickleSizer* s,
                                                     const param_type& p) {
   GetParamSize(s, p.IsValid());
-  if (p.IsValid())
+  if (p.IsValid()) {
     GetParamSize(s, p.GetHandle());
+    ParamTraits<base::UnguessableToken>::GetSize(sizer, 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);
   ParamTraits<HandleWin>::Write(m, handle_win);
 
   // If the caller intended to pass ownership to the IPC stack, release a
   // reference.
   if (p.OwnershipPassesToIPC())
     p.Close();
+
+  ParamTraits<base::UnguessableToken>::Write(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 (!ParamTraits<HandleWin>::Read(m, iter, &handle_win))
     return false;
-  *r = base::SharedMemoryHandle(handle_win.get_handle());
+
+  base::UnguessableToken guid;
+  if (!ParamTraits<base::UnguessableToken>::Read(m, iter, &guid))
+    return false;
+
+  *r = base::SharedMemoryHandle(handle_win.get_handle(), guid);
   return true;
 }
 
 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())
+  if (p.IsValid()) {
     sizer->AddAttachment();
+    ParamTraits<base::UnguessableToken>::GetSize(sizer, 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;
 
   if (p.OwnershipPassesToIPC()) {
     if (!m->WriteAttachment(new internal::PlatformFileAttachment(
             base::ScopedFD(p.GetHandle()))))
       NOTREACHED();
   } else {
     if (!m->WriteAttachment(
             new internal::PlatformFileAttachment(p.GetHandle())))
       NOTREACHED();
   }
+  ParamTraits<base::UnguessableToken>::Write(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;
 
   scoped_refptr<base::Pickle::Attachment> attachment;
   if (!m->ReadAttachment(iter, &attachment))
     return false;
 
   if (static_cast<MessageAttachment*>(attachment.get())->GetType() !=
       MessageAttachment::Type::PLATFORM_FILE) {
     return false;
   }
 
-  *r = base::SharedMemoryHandle(base::FileDescriptor(
-      static_cast<internal::PlatformFileAttachment*>(attachment.get())
-          ->TakePlatformFile(),
-      true));
+  base::UnguessableToken guid;
+  if (!ParamTraits<base::UnguessableToken>::Read(m, iter, &guid))
+    return false;
+
+  *r = base::SharedMemoryHandle(
+      base::FileDescriptor(
+          static_cast<internal::PlatformFileAttachment*>(attachment.get())
+              ->TakePlatformFile(),
+          true),
+      guid);
   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()));
   }
+  l->append("GUID: ");
+  ParamTraits<base::UnguessableToken>::Log(p.GetGUID(), l);
 }
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
 #if defined(OS_WIN)
 void ParamTraits<PlatformFileForTransit>::GetSize(base::PickleSizer* s,
                                                   const param_type& p) {
   GetParamSize(s, p.IsValid());
   if (p.IsValid())
     GetParamSize(s, p.GetHandle());
 }
@@ skipping 478 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC