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

remoting/host/chromoting_param_traits.cc

 // Copyright 2013 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 "remoting/host/chromoting_param_traits.h"
 
 #include <stdint.h>
 
 #include "base/strings/stringprintf.h"
 #include "ipc/ipc_message_utils.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace IPC {
 
 // static
+void ParamTraits<webrtc::DesktopVector>::GetSize(base::PickleSizer* s,
+                                                 const param_type& p) {
+  GetParamSize(s, p.x());
+  GetParamSize(s, p.y());
+}
+
+// static
 void ParamTraits<webrtc::DesktopVector>::Write(base::Pickle* m,
                                                const webrtc::DesktopVector& p) {
   m->WriteInt(p.x());
   m->WriteInt(p.y());
 }
 
 // static
 bool ParamTraits<webrtc::DesktopVector>::Read(const base::Pickle* m,
                                               base::PickleIterator* iter,
                                               webrtc::DesktopVector* r) {
   int x, y;
   if (!iter->ReadInt(&x) || !iter->ReadInt(&y))
     return false;
   *r = webrtc::DesktopVector(x, y);
   return true;
 }
 
 // static
 void ParamTraits<webrtc::DesktopVector>::Log(const webrtc::DesktopVector& p,
                                              std::string* l) {
   l->append(base::StringPrintf("webrtc::DesktopVector(%d, %d)",
                                p.x(), p.y()));
 }
 
 // static
+void ParamTraits<webrtc::DesktopSize>::GetSize(base::PickleSizer* s,
+                                               const param_type& p) {
+  GetParamSize(s, p.width());
+  GetParamSize(s, p.height());
+}
+
+// static
 void ParamTraits<webrtc::DesktopSize>::Write(base::Pickle* m,
                                              const webrtc::DesktopSize& p) {
   m->WriteInt(p.width());
   m->WriteInt(p.height());
 }
 
 // static
 bool ParamTraits<webrtc::DesktopSize>::Read(const base::Pickle* m,
                                             base::PickleIterator* iter,
                                             webrtc::DesktopSize* r) {
   int width, height;
   if (!iter->ReadInt(&width) || !iter->ReadInt(&height))
     return false;
   *r = webrtc::DesktopSize(width, height);
   return true;
 }
 
 // static
 void ParamTraits<webrtc::DesktopSize>::Log(const webrtc::DesktopSize& p,
                                            std::string* l) {
   l->append(base::StringPrintf("webrtc::DesktopSize(%d, %d)",
                                p.width(), p.height()));
 }
 
 // static
+void ParamTraits<webrtc::DesktopRect>::GetSize(base::PickleSizer* s,
+                                               const param_type& p) {
+  GetParamSize(s, p.left());
+  GetParamSize(s, p.top());
+  GetParamSize(s, p.right());
+  GetParamSize(s, p.bottom());
+}
+
+// static
 void ParamTraits<webrtc::DesktopRect>::Write(base::Pickle* m,
                                              const webrtc::DesktopRect& p) {
   m->WriteInt(p.left());
   m->WriteInt(p.top());
   m->WriteInt(p.right());
   m->WriteInt(p.bottom());
 }
 
 // static
 bool ParamTraits<webrtc::DesktopRect>::Read(const base::Pickle* m,
@@ skipping 107 matching lines @@
 // static
 void ParamTraits<remoting::ScreenResolution>::Log(
     const remoting::ScreenResolution& p,
     std::string* l) {
   l->append(base::StringPrintf("webrtc::ScreenResolution(%d, %d, %d, %d)",
                                p.dimensions().width(), p.dimensions().height(),
                                p.dpi().x(), p.dpi().y()));
 }
 
 // static
+void ParamTraits<net::IPAddress>::GetSize(base::PickleSizer* s,
+                                          const param_type& p) {
+  GetParamSize(s, p.bytes());
+}
+
+// static
 void ParamTraits<net::IPAddress>::Write(base::Pickle* m, const param_type& p) {
   WriteParam(m, p.bytes());
 }
 
 // static
 bool ParamTraits<net::IPAddress>::Read(const base::Pickle* m,
                                        base::PickleIterator* iter,
                                        param_type* p) {
   std::vector<uint8_t> bytes;
   if (!ReadParam(m, iter, &bytes))
     return false;
 
   net::IPAddress address(bytes);
   if (address.empty() || address.IsValid()) {
     *p = address;
     return true;
   }
   return false;
 }
 
 // static
 void ParamTraits<net::IPAddress>::Log(const param_type& p, std::string* l) {
   l->append("IPAddress:" + (p.empty() ? "(empty)" : p.ToString()));
 }
 
 // static
+void ParamTraits<net::IPEndPoint>::GetSize(base::PickleSizer* s,
+                                           const param_type& p) {
+  GetParamSize(s, p.address());
+  GetParamSize(s, p.port());
+}
+
+// static
 void ParamTraits<net::IPEndPoint>::Write(base::Pickle* m, const param_type& p) {
   WriteParam(m, p.address());
   WriteParam(m, p.port());
 }
 
 // static
 bool ParamTraits<net::IPEndPoint>::Read(const base::Pickle* m,
                                         base::PickleIterator* iter,
                                         param_type* p) {
   net::IPAddress address;
   uint16_t port;
   if (!ReadParam(m, iter, &address) || !ReadParam(m, iter, &port))
     return false;
 
   *p = net::IPEndPoint(address, port);
   return true;
 }
 
 // static
 void ParamTraits<net::IPEndPoint>::Log(const param_type& p, std::string* l) {
   l->append("IPEndPoint: " + p.ToString());
 }
 
 }  // namespace IPC