Generate param traits size methods for IPC files in content/ (and traits it depends on).

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 617 matching lines @@
 }
 
 void ParamTraits<base::DictionaryValue>::Log(const param_type& p,
                                              std::string* l) {
   std::string json;
   base::JSONWriter::Write(p, &json);
   l->append(json);
 }
 
 #if defined(OS_POSIX)
+void ParamTraits<base::FileDescriptor>::GetSize(base::PickleSizer* sizer,
+                                                const param_type& p) {
+  sizer->AddBool();
+  sizer->AddAttachment();
+}
+
 void ParamTraits<base::FileDescriptor>::Write(base::Pickle* m,
                                               const param_type& p) {
   const bool valid = p.fd >= 0;
   WriteParam(m, valid);
 
   if (!valid)
     return;
 
   if (p.auto_close) {
     if (!m->WriteAttachment(
@@ skipping 32 matching lines @@
                                             std::string* l) {
   if (p.auto_close) {
     l->append(base::StringPrintf("FD(%d auto-close)", p.fd));
   } 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());
+  sizer->AddUInt32();
+}
+
 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);
   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
@@ skipping 19 matching lines @@
   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) {
+  s->AddBool();
+  if (p.NeedsBrokering()) {
+    GetParamSize(s, p.GetHandle());
+  } else {
+    s->AddInt();
+  }
+}
+
 void ParamTraits<base::SharedMemoryHandle>::Write(base::Pickle* m,
                                                   const param_type& p) {
   m->WriteBool(p.NeedsBrokering());
 
   if (p.NeedsBrokering()) {
     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.
@@ skipping 435 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC