Make SharedMemoryHandle a class on windows.

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)
+#if (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_WIN)
 #include "base/memory/shared_memory_handle.h"
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+#endif  // (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_WIN)
 
 #if defined(OS_WIN)
 #include <tchar.h>
+#include "ipc/handle_win.h"
 #endif
 
 namespace IPC {
 
 namespace {
 
 const int kMaxRecursionDepth = 100;
 
 template<typename CharType>
 void LogBytes(const std::vector<CharType>& data, std::string* out) {
@@ skipping 546 matching lines @@
   return true;
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
                                                 std::string* l) {
   if (p.GetType() == base::SharedMemoryHandle::POSIX) {
     l->append(base::StringPrintf("Mechanism POSIX Fd"));
     ParamTraits<base::FileDescriptor>::Log(p.GetFileDescriptor(), l);
   }
 }
+#elif defined(OS_WIN)
+void ParamTraits<base::SharedMemoryHandle>::Write(Message* m,
+                                                  const param_type& p) {
+  // Longs on windows are 32 bits.
+  uint32_t pid = p.GetPID();
+  m->WriteUInt32(pid);
+  m->WriteBool(p.NeedsBrokering());
+
+  if (p.NeedsBrokering()) {
+    HandleWin handle_win(p.GetHandle(), HandleWin::DUPLICATE);
+    ParamTraits<HandleWin>::Write(m, handle_win);
+  } else {
+    m->WriteInt(HandleToLong(p.GetHandle()));
+  }
+}
+
+bool ParamTraits<base::SharedMemoryHandle>::Read(const Message* m,
+                                                 base::PickleIterator* iter,
+                                                 param_type* r) {
+  uint32_t pid_int;
+  if (!iter->ReadUInt32(&pid_int))
+    return false;
+  base::ProcessId pid = pid_int;
+
+  bool needs_brokering;
+  if (!iter->ReadBool(&needs_brokering))
+    return false;
+
+  if (needs_brokering) {
+    HandleWin handle_win;
+    if (!ParamTraits<HandleWin>::Read(m, iter, &handle_win))
+      return false;
+    *r = base::SharedMemoryHandle(handle_win.get_handle(), pid);
+    return true;
+  }
+
+  int handle_int;
+  if (!iter->ReadInt(&handle_int))
+    return false;
+  HANDLE handle = LongToHandle(handle_int);
+  *r = base::SharedMemoryHandle(handle, pid);
+  return true;
+}
+
+void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
+                                                std::string* l) {
+  LogParam(p.GetPID(), l);
+  l->append(" ");
+  LogParam(p.GetHandle(), l);
+  l->append(" needs brokering: ");
+  LogParam(p.NeedsBrokering(), 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 339 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC