Make PlatformFileForTransit its own 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/files/file_path.h"
@@ skipping 17 matching lines @@
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 #include "ipc/mach_port_mac.h"
 #endif
 
 #if defined(OS_WIN)
 #include <tchar.h>
 #include "ipc/handle_win.h"
+#include "ipc/ipc_platform_file.h"
 #endif
 
 namespace IPC {
 
 namespace {
 
 const int kMaxRecursionDepth = 200;
 
 template<typename CharType>
 void LogBytes(const std::vector<CharType>& data, std::string* out) {
@@ skipping 787 matching lines @@
 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()));
   }
 }
 #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.GetHandle());
+}
+
+void ParamTraits<PlatformFileForTransit>::Write(base::Pickle* m,
+                                                const param_type& p) {
+  HandleWin handle_win(p.GetHandle(), HandleWin::DUPLICATE);
+  ParamTraits<HandleWin>::Write(m, handle_win);
+  ::CloseHandle(p.GetHandle());
+}
+
+bool ParamTraits<PlatformFileForTransit>::Read(const base::Pickle* m,
+                                               base::PickleIterator* iter,
+                                               param_type* r) {
+  HandleWin handle_win;
+  if (!ParamTraits<HandleWin>::Read(m, iter, &handle_win))
+    return false;
+  *r = PlatformFileForTransit(handle_win.get_handle());
+  return true;
+}
+
+void ParamTraits<PlatformFileForTransit>::Log(const param_type& p,
+                                              std::string* l) {
+  LogParam(p.GetHandle(), l);
+}
+#endif  // defined(OS_WIN)
+
 void ParamTraits<base::FilePath>::GetSize(base::PickleSizer* sizer,
                                           const param_type& p) {
   p.GetSizeForPickle(sizer);
 }
 
 void ParamTraits<base::FilePath>::Write(base::Pickle* m, const param_type& p) {
   p.WriteToPickle(m);
 }
 
 bool ParamTraits<base::FilePath>::Read(const base::Pickle* m,
@@ skipping 433 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC