1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/common/content_param_traits.h"
6
7 #include "base/strings/string_number_conversions.h"
8 #include "content/common/input/web_input_event_traits.h"
9 #include "net/base/ip_endpoint.h"
10 #include "ui/gfx/range/range.h"
11
12 namespace IPC {
13
Write(Message * m,const param_type & p)14 void ParamTraits<net::IPEndPoint>::Write(Message* m, const param_type& p) {
15 WriteParam(m, p.address());
16 WriteParam(m, p.port());
17 }
18
Read(const Message * m,PickleIterator * iter,param_type * p)19 bool ParamTraits<net::IPEndPoint>::Read(const Message* m, PickleIterator* iter,
20 param_type* p) {
21 net::IPAddressNumber address;
22 int port;
23 if (!ReadParam(m, iter, &address) || !ReadParam(m, iter, &port))
24 return false;
25 *p = net::IPEndPoint(address, port);
26 return true;
27 }
28
Log(const param_type & p,std::string * l)29 void ParamTraits<net::IPEndPoint>::Log(const param_type& p, std::string* l) {
30 LogParam("IPEndPoint:" + p.ToString(), l);
31 }
32
Write(Message * m,const gfx::Range & r)33 void ParamTraits<gfx::Range>::Write(Message* m, const gfx::Range& r) {
34 m->WriteUInt64(r.start());
35 m->WriteUInt64(r.end());
36 }
37
Read(const Message * m,PickleIterator * iter,gfx::Range * r)38 bool ParamTraits<gfx::Range>::Read(const Message* m,
39 PickleIterator* iter,
40 gfx::Range* r) {
41 uint64 start, end;
42 if (!m->ReadUInt64(iter, &start) || !m->ReadUInt64(iter, &end))
43 return false;
44 r->set_start(start);
45 r->set_end(end);
46 return true;
47 }
48
Log(const gfx::Range & r,std::string * l)49 void ParamTraits<gfx::Range>::Log(const gfx::Range& r, std::string* l) {
50 l->append(base::StringPrintf("(%" PRIuS ", %" PRIuS ")", r.start(), r.end()));
51 }
52
Write(Message * m,const param_type & p)53 void ParamTraits<WebInputEventPointer>::Write(Message* m, const param_type& p) {
54 m->WriteData(reinterpret_cast<const char*>(p), p->size);
55 }
56
Read(const Message * m,PickleIterator * iter,param_type * r)57 bool ParamTraits<WebInputEventPointer>::Read(const Message* m,
58 PickleIterator* iter,
59 param_type* r) {
60 const char* data;
61 int data_length;
62 if (!m->ReadData(iter, &data, &data_length)) {
63 NOTREACHED();
64 return false;
65 }
66 if (data_length < static_cast<int>(sizeof(blink::WebInputEvent))) {
67 NOTREACHED();
68 return false;
69 }
70 param_type event = reinterpret_cast<param_type>(data);
71 // Check that the data size matches that of the event.
72 if (data_length != static_cast<int>(event->size)) {
73 NOTREACHED();
74 return false;
75 }
76 const size_t expected_size_for_type =
77 content::WebInputEventTraits::GetSize(event->type);
78 if (data_length != static_cast<int>(expected_size_for_type)) {
79 NOTREACHED();
80 return false;
81 }
82 *r = event;
83 return true;
84 }
85
Log(const param_type & p,std::string * l)86 void ParamTraits<WebInputEventPointer>::Log(const param_type& p,
87 std::string* l) {
88 l->append("(");
89 LogParam(p->size, l);
90 l->append(", ");
91 LogParam(p->type, l);
92 l->append(", ");
93 LogParam(p->timeStampSeconds, l);
94 l->append(")");
95 }
96
97 } // namespace IPC
98
99 // Generate param traits write methods.
100 #include "ipc/param_traits_write_macros.h"
101 namespace IPC {
102 #undef CONTENT_COMMON_CONTENT_PARAM_TRAITS_MACROS_H_
103 #include "content/common/content_param_traits_macros.h"
104 } // namespace IPC
105
106 // Generate param traits read methods.
107 #include "ipc/param_traits_read_macros.h"
108 namespace IPC {
109 #undef CONTENT_COMMON_CONTENT_PARAM_TRAITS_MACROS_H_
110 #include "content/common/content_param_traits_macros.h"
111 } // namespace IPC
112
113 // Generate param traits log methods.
114 #include "ipc/param_traits_log_macros.h"
115 namespace IPC {
116 #undef CONTENT_COMMON_CONTENT_PARAM_TRAITS_MACROS_H_
117 #include "content/common/content_param_traits_macros.h"
118 } // namespace IPC
119