OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/public/common/common_param_traits.h" | 5 #include "content/public/common/common_param_traits.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 | 8 |
9 #include "content/public/common/content_constants.h" | 9 #include "content/public/common/content_constants.h" |
10 #include "content/public/common/page_state.h" | 10 #include "content/public/common/page_state.h" |
11 #include "content/public/common/referrer.h" | 11 #include "content/public/common/referrer.h" |
12 #include "net/base/host_port_pair.h" | 12 #include "net/base/host_port_pair.h" |
13 #include "net/base/ip_address.h" | 13 #include "net/base/ip_address.h" |
14 #include "net/base/ip_endpoint.h" | 14 #include "net/base/ip_endpoint.h" |
15 | 15 |
16 namespace IPC { | 16 namespace IPC { |
17 | 17 |
| 18 void ParamTraits<url::Origin>::GetSize(base::PickleSizer* s, |
| 19 const param_type& p) { |
| 20 GetParamSize(s, p.unique()); |
| 21 GetParamSize(s, p.scheme()); |
| 22 GetParamSize(s, p.host()); |
| 23 GetParamSize(s, p.port()); |
| 24 } |
| 25 |
18 void ParamTraits<url::Origin>::Write(base::Pickle* m, const url::Origin& p) { | 26 void ParamTraits<url::Origin>::Write(base::Pickle* m, const url::Origin& p) { |
19 WriteParam(m, p.unique()); | 27 WriteParam(m, p.unique()); |
20 WriteParam(m, p.scheme()); | 28 WriteParam(m, p.scheme()); |
21 WriteParam(m, p.host()); | 29 WriteParam(m, p.host()); |
22 WriteParam(m, p.port()); | 30 WriteParam(m, p.port()); |
23 } | 31 } |
24 | 32 |
25 bool ParamTraits<url::Origin>::Read(const base::Pickle* m, | 33 bool ParamTraits<url::Origin>::Read(const base::Pickle* m, |
26 base::PickleIterator* iter, | 34 base::PickleIterator* iter, |
27 url::Origin* p) { | 35 url::Origin* p) { |
(...skipping 17 matching lines...) Expand all Loading... |
45 if (!unique && p->unique()) | 53 if (!unique && p->unique()) |
46 return false; | 54 return false; |
47 | 55 |
48 return true; | 56 return true; |
49 } | 57 } |
50 | 58 |
51 void ParamTraits<url::Origin>::Log(const url::Origin& p, std::string* l) { | 59 void ParamTraits<url::Origin>::Log(const url::Origin& p, std::string* l) { |
52 l->append(p.Serialize()); | 60 l->append(p.Serialize()); |
53 } | 61 } |
54 | 62 |
| 63 void ParamTraits<net::HostPortPair>::GetSize(base::PickleSizer* s, |
| 64 const param_type& p) { |
| 65 GetParamSize(s, p.host()); |
| 66 GetParamSize(s, p.port()); |
| 67 } |
| 68 |
55 void ParamTraits<net::HostPortPair>::Write(base::Pickle* m, | 69 void ParamTraits<net::HostPortPair>::Write(base::Pickle* m, |
56 const param_type& p) { | 70 const param_type& p) { |
57 WriteParam(m, p.host()); | 71 WriteParam(m, p.host()); |
58 WriteParam(m, p.port()); | 72 WriteParam(m, p.port()); |
59 } | 73 } |
60 | 74 |
61 bool ParamTraits<net::HostPortPair>::Read(const base::Pickle* m, | 75 bool ParamTraits<net::HostPortPair>::Read(const base::Pickle* m, |
62 base::PickleIterator* iter, | 76 base::PickleIterator* iter, |
63 param_type* r) { | 77 param_type* r) { |
64 std::string host; | 78 std::string host; |
65 uint16_t port; | 79 uint16_t port; |
66 if (!ReadParam(m, iter, &host) || !ReadParam(m, iter, &port)) | 80 if (!ReadParam(m, iter, &host) || !ReadParam(m, iter, &port)) |
67 return false; | 81 return false; |
68 | 82 |
69 r->set_host(host); | 83 r->set_host(host); |
70 r->set_port(port); | 84 r->set_port(port); |
71 return true; | 85 return true; |
72 } | 86 } |
73 | 87 |
74 void ParamTraits<net::HostPortPair>::Log(const param_type& p, std::string* l) { | 88 void ParamTraits<net::HostPortPair>::Log(const param_type& p, std::string* l) { |
75 l->append(p.ToString()); | 89 l->append(p.ToString()); |
76 } | 90 } |
77 | 91 |
| 92 void ParamTraits<net::IPEndPoint>::GetSize(base::PickleSizer* s, |
| 93 const param_type& p) { |
| 94 GetParamSize(s, p.address()); |
| 95 GetParamSize(s, p.port()); |
| 96 } |
| 97 |
78 void ParamTraits<net::IPEndPoint>::Write(base::Pickle* m, const param_type& p) { | 98 void ParamTraits<net::IPEndPoint>::Write(base::Pickle* m, const param_type& p) { |
79 WriteParam(m, p.address()); | 99 WriteParam(m, p.address()); |
80 WriteParam(m, p.port()); | 100 WriteParam(m, p.port()); |
81 } | 101 } |
82 | 102 |
83 bool ParamTraits<net::IPEndPoint>::Read(const base::Pickle* m, | 103 bool ParamTraits<net::IPEndPoint>::Read(const base::Pickle* m, |
84 base::PickleIterator* iter, | 104 base::PickleIterator* iter, |
85 param_type* p) { | 105 param_type* p) { |
86 net::IPAddress address; | 106 net::IPAddress address; |
87 uint16_t port; | 107 uint16_t port; |
88 if (!ReadParam(m, iter, &address) || !ReadParam(m, iter, &port)) | 108 if (!ReadParam(m, iter, &address) || !ReadParam(m, iter, &port)) |
89 return false; | 109 return false; |
90 if (!address.empty() && !address.IsValid()) | 110 if (!address.empty() && !address.IsValid()) |
91 return false; | 111 return false; |
92 | 112 |
93 *p = net::IPEndPoint(address, port); | 113 *p = net::IPEndPoint(address, port); |
94 return true; | 114 return true; |
95 } | 115 } |
96 | 116 |
97 void ParamTraits<net::IPEndPoint>::Log(const param_type& p, std::string* l) { | 117 void ParamTraits<net::IPEndPoint>::Log(const param_type& p, std::string* l) { |
98 LogParam("IPEndPoint:" + p.ToString(), l); | 118 LogParam("IPEndPoint:" + p.ToString(), l); |
99 } | 119 } |
100 | 120 |
| 121 void ParamTraits<net::IPAddress>::GetSize(base::PickleSizer* s, |
| 122 const param_type& p) { |
| 123 GetParamSize(s, p.bytes()); |
| 124 } |
| 125 |
101 void ParamTraits<net::IPAddress>::Write(base::Pickle* m, const param_type& p) { | 126 void ParamTraits<net::IPAddress>::Write(base::Pickle* m, const param_type& p) { |
102 WriteParam(m, p.bytes()); | 127 WriteParam(m, p.bytes()); |
103 } | 128 } |
104 | 129 |
105 bool ParamTraits<net::IPAddress>::Read(const base::Pickle* m, | 130 bool ParamTraits<net::IPAddress>::Read(const base::Pickle* m, |
106 base::PickleIterator* iter, | 131 base::PickleIterator* iter, |
107 param_type* p) { | 132 param_type* p) { |
108 std::vector<uint8_t> bytes; | 133 std::vector<uint8_t> bytes; |
109 if (!ReadParam(m, iter, &bytes)) | 134 if (!ReadParam(m, iter, &bytes)) |
110 return false; | 135 return false; |
111 if (bytes.size() && | 136 if (bytes.size() && |
112 bytes.size() != net::IPAddress::kIPv4AddressSize && | 137 bytes.size() != net::IPAddress::kIPv4AddressSize && |
113 bytes.size() != net::IPAddress::kIPv6AddressSize) { | 138 bytes.size() != net::IPAddress::kIPv6AddressSize) { |
114 return false; | 139 return false; |
115 } | 140 } |
116 *p = net::IPAddress(bytes); | 141 *p = net::IPAddress(bytes); |
117 return true; | 142 return true; |
118 } | 143 } |
119 | 144 |
120 void ParamTraits<net::IPAddress>::Log(const param_type& p, std::string* l) { | 145 void ParamTraits<net::IPAddress>::Log(const param_type& p, std::string* l) { |
121 LogParam("IPAddress:" + (p.empty() ? "(empty)" : p.ToString()), l); | 146 LogParam("IPAddress:" + (p.empty() ? "(empty)" : p.ToString()), l); |
122 } | 147 } |
123 | 148 |
| 149 void ParamTraits<content::PageState>::GetSize(base::PickleSizer* s, |
| 150 const param_type& p) { |
| 151 GetParamSize(s, p.ToEncodedData()); |
| 152 } |
| 153 |
124 void ParamTraits<content::PageState>::Write(base::Pickle* m, | 154 void ParamTraits<content::PageState>::Write(base::Pickle* m, |
125 const param_type& p) { | 155 const param_type& p) { |
126 WriteParam(m, p.ToEncodedData()); | 156 WriteParam(m, p.ToEncodedData()); |
127 } | 157 } |
128 | 158 |
129 bool ParamTraits<content::PageState>::Read(const base::Pickle* m, | 159 bool ParamTraits<content::PageState>::Read(const base::Pickle* m, |
130 base::PickleIterator* iter, | 160 base::PickleIterator* iter, |
131 param_type* r) { | 161 param_type* r) { |
132 std::string data; | 162 std::string data; |
133 if (!ReadParam(m, iter, &data)) | 163 if (!ReadParam(m, iter, &data)) |
134 return false; | 164 return false; |
135 *r = content::PageState::CreateFromEncodedData(data); | 165 *r = content::PageState::CreateFromEncodedData(data); |
136 return true; | 166 return true; |
137 } | 167 } |
138 | 168 |
139 void ParamTraits<content::PageState>::Log( | 169 void ParamTraits<content::PageState>::Log( |
140 const param_type& p, std::string* l) { | 170 const param_type& p, std::string* l) { |
141 l->append("("); | 171 l->append("("); |
142 LogParam(p.ToEncodedData(), l); | 172 LogParam(p.ToEncodedData(), l); |
143 l->append(")"); | 173 l->append(")"); |
144 } | 174 } |
145 | 175 |
146 } // namespace IPC | 176 } // namespace IPC |
147 | 177 |
| 178 // Generate param traits size methods. |
| 179 #include "ipc/param_traits_size_macros.h" |
| 180 namespace IPC { |
| 181 #undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_ |
| 182 #include "content/public/common/common_param_traits_macros.h" |
| 183 } |
| 184 |
148 // Generate param traits write methods. | 185 // Generate param traits write methods. |
149 #include "ipc/param_traits_write_macros.h" | 186 #include "ipc/param_traits_write_macros.h" |
150 namespace IPC { | 187 namespace IPC { |
151 #undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_ | 188 #undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_ |
152 #include "content/public/common/common_param_traits_macros.h" | 189 #include "content/public/common/common_param_traits_macros.h" |
153 } // namespace IPC | 190 } // namespace IPC |
154 | 191 |
155 // Generate param traits read methods. | 192 // Generate param traits read methods. |
156 #include "ipc/param_traits_read_macros.h" | 193 #include "ipc/param_traits_read_macros.h" |
157 namespace IPC { | 194 namespace IPC { |
158 #undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_ | 195 #undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_ |
159 #include "content/public/common/common_param_traits_macros.h" | 196 #include "content/public/common/common_param_traits_macros.h" |
160 } // namespace IPC | 197 } // namespace IPC |
161 | 198 |
162 // Generate param traits log methods. | 199 // Generate param traits log methods. |
163 #include "ipc/param_traits_log_macros.h" | 200 #include "ipc/param_traits_log_macros.h" |
164 namespace IPC { | 201 namespace IPC { |
165 #undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_ | 202 #undef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_MACROS_H_ |
166 #include "content/public/common/common_param_traits_macros.h" | 203 #include "content/public/common/common_param_traits_macros.h" |
167 } // namespace IPC | 204 } // namespace IPC |
OLD | NEW |