Get rid of all pid references from 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 691 matching lines @@
                                                  param_type* r) {
   MachPortMac mach_port_mac;
   if (!ParamTraits<MachPortMac>::Read(m, iter, &mach_port_mac))
     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),
-                                base::GetCurrentProcId());
+                                static_cast<size_t>(size));
   return true;
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
                                                 std::string* l) {
   l->append("Mach port: ");
   LogParam(p.GetMemoryObject(), l);
 }
 
 #elif defined(OS_WIN)
 void ParamTraits<base::SharedMemoryHandle>::GetSize(base::PickleSizer* s,
                                                     const param_type& p) {
-  GetParamSize(s, p.NeedsBrokering());
-  if (p.NeedsBrokering()) {
+  GetParamSize(s, p.IsValid());
+  if (p.IsValid())
     GetParamSize(s, p.GetHandle());
-  } else {
-    GetParamSize(s, HandleToLong(p.GetHandle()));
-  }
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Write(base::Pickle* m,
                                                   const param_type& p) {
-  m->WriteBool(p.NeedsBrokering());
+  const bool valid = p.IsValid();
+  WriteParam(m, valid);
 
-  if (p.NeedsBrokering()) {
-    HandleWin handle_win(p.GetHandle(), HandleWin::DUPLICATE);
-    ParamTraits<HandleWin>::Write(m, handle_win);
+  if (!valid)
+    return;
 
-    // If the caller intended to pass ownership to the IPC stack, release a
-    // reference.
-    if (p.OwnershipPassesToIPC() && p.BelongsToCurrentProcess())
-      p.Close();
-  } else {
-    m->WriteInt(HandleToLong(p.GetHandle()));
-  }
+  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();
 }
 
 bool ParamTraits<base::SharedMemoryHandle>::Read(const base::Pickle* m,
                                                  base::PickleIterator* iter,
                                                  param_type* r) {
-  bool needs_brokering;
-  if (!iter->ReadBool(&needs_brokering))
+  *r = base::SharedMemoryHandle();
+
+  bool valid;
+  if (!ReadParam(m, iter, &valid))
     return false;
+  if (!valid)
+    return true;
 
-  if (needs_brokering) {
-    HandleWin handle_win;
-    if (!ParamTraits<HandleWin>::Read(m, iter, &handle_win))
-      return false;
-    *r = base::SharedMemoryHandle(handle_win.get_handle(),
-                                  base::GetCurrentProcId());
-    return true;
-  }
-
-  int handle_int;
-  if (!iter->ReadInt(&handle_int))
+  HandleWin handle_win;
+  if (!ParamTraits<HandleWin>::Read(m, iter, &handle_win))
     return false;
-  HANDLE handle = LongToHandle(handle_int);
-  *r = base::SharedMemoryHandle(handle, base::GetCurrentProcId());
+  *r = base::SharedMemoryHandle(handle_win.get_handle());
   return true;
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
                                                 std::string* l) {
   LogParam(p.GetHandle(), l);
-  l->append(" needs brokering: ");
-  LogParam(p.NeedsBrokering(), 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();
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Write(base::Pickle* m,
@@ skipping 541 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC