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 "ppapi/proxy/ppapi_param_traits.h" | 5 #include "ppapi/proxy/ppapi_param_traits.h" |
6 | 6 |
7 #include <string.h> // For memcpy | 7 #include <string.h> // For memcpy |
8 | 8 |
9 #include "ppapi/c/pp_file_info.h" | 9 #include "ppapi/c/pp_file_info.h" |
10 #include "ppapi/c/pp_resource.h" | 10 #include "ppapi/c/pp_resource.h" |
(...skipping 21 matching lines...) Expand all Loading... |
32 // Since we allocate the inner class when you call the default constructor and | 32 // Since we allocate the inner class when you call the default constructor and |
33 // transfer the inner class when you do operator=, the entire vector will end | 33 // transfer the inner class when you do operator=, the entire vector will end |
34 // up referring to the same inner class. Deserializing into this will just end | 34 // up referring to the same inner class. Deserializing into this will just end |
35 // up overwriting the same item over and over, since all the SerializedVars | 35 // up overwriting the same item over and over, since all the SerializedVars |
36 // will refer to the same thing. | 36 // will refer to the same thing. |
37 // | 37 // |
38 // The solution is to make a new object for each deserialized item, and then | 38 // The solution is to make a new object for each deserialized item, and then |
39 // add it to the vector one at a time. | 39 // add it to the vector one at a time. |
40 template<typename T> | 40 template<typename T> |
41 bool ReadVectorWithoutCopy(const Message* m, | 41 bool ReadVectorWithoutCopy(const Message* m, |
42 void** iter, | 42 PickleIterator* iter, |
43 std::vector<T>* output) { | 43 std::vector<T>* output) { |
44 // This part is just a copy of the the default ParamTraits vector Read(). | 44 // This part is just a copy of the the default ParamTraits vector Read(). |
45 int size; | 45 int size; |
46 // ReadLength() checks for < 0 itself. | 46 // ReadLength() checks for < 0 itself. |
47 if (!m->ReadLength(iter, &size)) | 47 if (!m->ReadLength(iter, &size)) |
48 return false; | 48 return false; |
49 // Resizing beforehand is not safe, see BUG 1006367 for details. | 49 // Resizing beforehand is not safe, see BUG 1006367 for details. |
50 if (INT_MAX / sizeof(T) <= static_cast<size_t>(size)) | 50 if (INT_MAX / sizeof(T) <= static_cast<size_t>(size)) |
51 return false; | 51 return false; |
52 | 52 |
(...skipping 21 matching lines...) Expand all Loading... |
74 } // namespace | 74 } // namespace |
75 | 75 |
76 // PP_Bool --------------------------------------------------------------------- | 76 // PP_Bool --------------------------------------------------------------------- |
77 | 77 |
78 // static | 78 // static |
79 void ParamTraits<PP_Bool>::Write(Message* m, const param_type& p) { | 79 void ParamTraits<PP_Bool>::Write(Message* m, const param_type& p) { |
80 ParamTraits<bool>::Write(m, PP_ToBool(p)); | 80 ParamTraits<bool>::Write(m, PP_ToBool(p)); |
81 } | 81 } |
82 | 82 |
83 // static | 83 // static |
84 bool ParamTraits<PP_Bool>::Read(const Message* m, void** iter, param_type* r) { | 84 bool ParamTraits<PP_Bool>::Read(const Message* m, |
| 85 PickleIterator* iter, |
| 86 param_type* r) { |
85 // We specifically want to be strict here about what types of input we accept, | 87 // We specifically want to be strict here about what types of input we accept, |
86 // which ParamTraits<bool> does for us. We don't want to deserialize "2" into | 88 // which ParamTraits<bool> does for us. We don't want to deserialize "2" into |
87 // a PP_Bool, for example. | 89 // a PP_Bool, for example. |
88 bool result = false; | 90 bool result = false; |
89 if (!ParamTraits<bool>::Read(m, iter, &result)) | 91 if (!ParamTraits<bool>::Read(m, iter, &result)) |
90 return false; | 92 return false; |
91 *r = PP_FromBool(result); | 93 *r = PP_FromBool(result); |
92 return true; | 94 return true; |
93 } | 95 } |
94 | 96 |
95 // static | 97 // static |
96 void ParamTraits<PP_Bool>::Log(const param_type& p, std::string* l) { | 98 void ParamTraits<PP_Bool>::Log(const param_type& p, std::string* l) { |
97 } | 99 } |
98 | 100 |
99 // PP_FileInfo ------------------------------------------------------------- | 101 // PP_FileInfo ------------------------------------------------------------- |
100 | 102 |
101 // static | 103 // static |
102 void ParamTraits<PP_FileInfo>::Write(Message* m, const param_type& p) { | 104 void ParamTraits<PP_FileInfo>::Write(Message* m, const param_type& p) { |
103 ParamTraits<int64_t>::Write(m, p.size); | 105 ParamTraits<int64_t>::Write(m, p.size); |
104 ParamTraits<int>::Write(m, static_cast<int>(p.type)); | 106 ParamTraits<int>::Write(m, static_cast<int>(p.type)); |
105 ParamTraits<int>::Write(m, static_cast<int>(p.system_type)); | 107 ParamTraits<int>::Write(m, static_cast<int>(p.system_type)); |
106 ParamTraits<double>::Write(m, p.creation_time); | 108 ParamTraits<double>::Write(m, p.creation_time); |
107 ParamTraits<double>::Write(m, p.last_access_time); | 109 ParamTraits<double>::Write(m, p.last_access_time); |
108 ParamTraits<double>::Write(m, p.last_modified_time); | 110 ParamTraits<double>::Write(m, p.last_modified_time); |
109 } | 111 } |
110 | 112 |
111 // static | 113 // static |
112 bool ParamTraits<PP_FileInfo>::Read(const Message* m, void** iter, | 114 bool ParamTraits<PP_FileInfo>::Read(const Message* m, PickleIterator* iter, |
113 param_type* r) { | 115 param_type* r) { |
114 int type, system_type; | 116 int type, system_type; |
115 if (!ParamTraits<int64_t>::Read(m, iter, &r->size) || | 117 if (!ParamTraits<int64_t>::Read(m, iter, &r->size) || |
116 !ParamTraits<int>::Read(m, iter, &type) || | 118 !ParamTraits<int>::Read(m, iter, &type) || |
117 !ParamTraits<int>::Read(m, iter, &system_type) || | 119 !ParamTraits<int>::Read(m, iter, &system_type) || |
118 !ParamTraits<double>::Read(m, iter, &r->creation_time) || | 120 !ParamTraits<double>::Read(m, iter, &r->creation_time) || |
119 !ParamTraits<double>::Read(m, iter, &r->last_access_time) || | 121 !ParamTraits<double>::Read(m, iter, &r->last_access_time) || |
120 !ParamTraits<double>::Read(m, iter, &r->last_modified_time)) | 122 !ParamTraits<double>::Read(m, iter, &r->last_modified_time)) |
121 return false; | 123 return false; |
122 if (type != PP_FILETYPE_REGULAR && | 124 if (type != PP_FILETYPE_REGULAR && |
(...skipping 18 matching lines...) Expand all Loading... |
141 | 143 |
142 // static | 144 // static |
143 void ParamTraits<PP_NetAddress_Private>::Write(Message* m, | 145 void ParamTraits<PP_NetAddress_Private>::Write(Message* m, |
144 const param_type& p) { | 146 const param_type& p) { |
145 WriteParam(m, p.size); | 147 WriteParam(m, p.size); |
146 m->WriteBytes(p.data, static_cast<int>(p.size)); | 148 m->WriteBytes(p.data, static_cast<int>(p.size)); |
147 } | 149 } |
148 | 150 |
149 // static | 151 // static |
150 bool ParamTraits<PP_NetAddress_Private>::Read(const Message* m, | 152 bool ParamTraits<PP_NetAddress_Private>::Read(const Message* m, |
151 void** iter, | 153 PickleIterator* iter, |
152 param_type* p) { | 154 param_type* p) { |
153 uint16 size; | 155 uint16 size; |
154 if (!ReadParam(m, iter, &size)) | 156 if (!ReadParam(m, iter, &size)) |
155 return false; | 157 return false; |
156 if (size > sizeof(p->data)) | 158 if (size > sizeof(p->data)) |
157 return false; | 159 return false; |
158 p->size = size; | 160 p->size = size; |
159 | 161 |
160 const char* data; | 162 const char* data; |
161 if (!m->ReadBytes(iter, &data, size)) | 163 if (!m->ReadBytes(iter, &data, size)) |
(...skipping 12 matching lines...) Expand all Loading... |
174 | 176 |
175 // PP_ObjectProperty ----------------------------------------------------------- | 177 // PP_ObjectProperty ----------------------------------------------------------- |
176 | 178 |
177 // static | 179 // static |
178 void ParamTraits<PP_ObjectProperty>::Write(Message* m, const param_type& p) { | 180 void ParamTraits<PP_ObjectProperty>::Write(Message* m, const param_type& p) { |
179 // FIXME(brettw); | 181 // FIXME(brettw); |
180 } | 182 } |
181 | 183 |
182 // static | 184 // static |
183 bool ParamTraits<PP_ObjectProperty>::Read(const Message* m, | 185 bool ParamTraits<PP_ObjectProperty>::Read(const Message* m, |
184 void** iter, | 186 PickleIterator* iter, |
185 param_type* r) { | 187 param_type* r) { |
186 // FIXME(brettw); | 188 // FIXME(brettw); |
187 return true; | 189 return true; |
188 } | 190 } |
189 | 191 |
190 // static | 192 // static |
191 void ParamTraits<PP_ObjectProperty>::Log(const param_type& p, std::string* l) { | 193 void ParamTraits<PP_ObjectProperty>::Log(const param_type& p, std::string* l) { |
192 } | 194 } |
193 | 195 |
194 // PPBFlash_DrawGlyphs_Params -------------------------------------------------- | 196 // PPBFlash_DrawGlyphs_Params -------------------------------------------------- |
(...skipping 18 matching lines...) Expand all Loading... |
213 ParamTraits<float>::Write(m, p.transformation[2][1]); | 215 ParamTraits<float>::Write(m, p.transformation[2][1]); |
214 ParamTraits<float>::Write(m, p.transformation[2][2]); | 216 ParamTraits<float>::Write(m, p.transformation[2][2]); |
215 ParamTraits<PP_Bool>::Write(m, p.allow_subpixel_aa); | 217 ParamTraits<PP_Bool>::Write(m, p.allow_subpixel_aa); |
216 ParamTraits<std::vector<uint16_t> >::Write(m, p.glyph_indices); | 218 ParamTraits<std::vector<uint16_t> >::Write(m, p.glyph_indices); |
217 ParamTraits<std::vector<PP_Point> >::Write(m, p.glyph_advances); | 219 ParamTraits<std::vector<PP_Point> >::Write(m, p.glyph_advances); |
218 } | 220 } |
219 | 221 |
220 // static | 222 // static |
221 bool ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Read( | 223 bool ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Read( |
222 const Message* m, | 224 const Message* m, |
223 void** iter, | 225 PickleIterator* iter, |
224 param_type* r) { | 226 param_type* r) { |
225 return | 227 return |
226 ParamTraits<PP_Instance>::Read(m, iter, &r->instance) && | 228 ParamTraits<PP_Instance>::Read(m, iter, &r->instance) && |
227 ParamTraits<ppapi::HostResource>::Read(m, iter, &r->image_data) && | 229 ParamTraits<ppapi::HostResource>::Read(m, iter, &r->image_data) && |
228 ParamTraits<ppapi::proxy::SerializedFontDescription>::Read(m, iter, | 230 ParamTraits<ppapi::proxy::SerializedFontDescription>::Read(m, iter, |
229 &r->font_desc) && | 231 &r->font_desc) && |
230 ParamTraits<uint32_t>::Read(m, iter, &r->color) && | 232 ParamTraits<uint32_t>::Read(m, iter, &r->color) && |
231 ParamTraits<PP_Point>::Read(m, iter, &r->position) && | 233 ParamTraits<PP_Point>::Read(m, iter, &r->position) && |
232 ParamTraits<PP_Rect>::Read(m, iter, &r->clip) && | 234 ParamTraits<PP_Rect>::Read(m, iter, &r->clip) && |
233 ParamTraits<float>::Read(m, iter, &r->transformation[0][0]) && | 235 ParamTraits<float>::Read(m, iter, &r->transformation[0][0]) && |
(...skipping 24 matching lines...) Expand all Loading... |
258 void ParamTraits<ppapi::PPB_FileRef_CreateInfo>::Write(Message* m, | 260 void ParamTraits<ppapi::PPB_FileRef_CreateInfo>::Write(Message* m, |
259 const param_type& p) { | 261 const param_type& p) { |
260 ParamTraits<ppapi::HostResource>::Write(m, p.resource); | 262 ParamTraits<ppapi::HostResource>::Write(m, p.resource); |
261 ParamTraits<int>::Write(m, p.file_system_type); | 263 ParamTraits<int>::Write(m, p.file_system_type); |
262 ParamTraits<std::string>::Write(m, p.path); | 264 ParamTraits<std::string>::Write(m, p.path); |
263 ParamTraits<std::string>::Write(m, p.name); | 265 ParamTraits<std::string>::Write(m, p.name); |
264 } | 266 } |
265 | 267 |
266 // static | 268 // static |
267 bool ParamTraits<ppapi::PPB_FileRef_CreateInfo>::Read(const Message* m, | 269 bool ParamTraits<ppapi::PPB_FileRef_CreateInfo>::Read(const Message* m, |
268 void** iter, | 270 PickleIterator* iter, |
269 param_type* r) { | 271 param_type* r) { |
270 return | 272 return |
271 ParamTraits<ppapi::HostResource>::Read(m, iter, &r->resource) && | 273 ParamTraits<ppapi::HostResource>::Read(m, iter, &r->resource) && |
272 ParamTraits<int>::Read(m, iter, &r->file_system_type) && | 274 ParamTraits<int>::Read(m, iter, &r->file_system_type) && |
273 ParamTraits<std::string>::Read(m, iter, &r->path) && | 275 ParamTraits<std::string>::Read(m, iter, &r->path) && |
274 ParamTraits<std::string>::Read(m, iter, &r->name); | 276 ParamTraits<std::string>::Read(m, iter, &r->name); |
275 } | 277 } |
276 | 278 |
277 // static | 279 // static |
278 void ParamTraits<ppapi::PPB_FileRef_CreateInfo>::Log(const param_type& p, | 280 void ParamTraits<ppapi::PPB_FileRef_CreateInfo>::Log(const param_type& p, |
(...skipping 10 matching lines...) Expand all Loading... |
289 ParamTraits<ppapi::HostResource>::Write(m, p.resource); | 291 ParamTraits<ppapi::HostResource>::Write(m, p.resource); |
290 ParamTraits<int64_t>::Write(m, p.bytes_sent); | 292 ParamTraits<int64_t>::Write(m, p.bytes_sent); |
291 ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_sent); | 293 ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_sent); |
292 ParamTraits<int64_t>::Write(m, p.bytes_received); | 294 ParamTraits<int64_t>::Write(m, p.bytes_received); |
293 ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_received); | 295 ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_received); |
294 } | 296 } |
295 | 297 |
296 // static | 298 // static |
297 bool ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Read( | 299 bool ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Read( |
298 const Message* m, | 300 const Message* m, |
299 void** iter, | 301 PickleIterator* iter, |
300 param_type* r) { | 302 param_type* r) { |
301 return | 303 return |
302 ParamTraits<PP_Instance>::Read(m, iter, &r->instance) && | 304 ParamTraits<PP_Instance>::Read(m, iter, &r->instance) && |
303 ParamTraits<ppapi::HostResource>::Read(m, iter, &r->resource) && | 305 ParamTraits<ppapi::HostResource>::Read(m, iter, &r->resource) && |
304 ParamTraits<int64_t>::Read(m, iter, &r->bytes_sent) && | 306 ParamTraits<int64_t>::Read(m, iter, &r->bytes_sent) && |
305 ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_sent) && | 307 ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_sent) && |
306 ParamTraits<int64_t>::Read(m, iter, &r->bytes_received) && | 308 ParamTraits<int64_t>::Read(m, iter, &r->bytes_received) && |
307 ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_received); | 309 ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_received); |
308 } | 310 } |
309 | 311 |
310 // static | 312 // static |
311 void ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Log( | 313 void ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Log( |
312 const param_type& p, | 314 const param_type& p, |
313 std::string* l) { | 315 std::string* l) { |
314 } | 316 } |
315 | 317 |
316 // SerializedDirEntry ---------------------------------------------------------- | 318 // SerializedDirEntry ---------------------------------------------------------- |
317 | 319 |
318 // static | 320 // static |
319 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Write(Message* m, | 321 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Write(Message* m, |
320 const param_type& p) { | 322 const param_type& p) { |
321 ParamTraits<std::string>::Write(m, p.name); | 323 ParamTraits<std::string>::Write(m, p.name); |
322 ParamTraits<bool>::Write(m, p.is_dir); | 324 ParamTraits<bool>::Write(m, p.is_dir); |
323 } | 325 } |
324 | 326 |
325 // static | 327 // static |
326 bool ParamTraits<ppapi::proxy::SerializedDirEntry>::Read(const Message* m, | 328 bool ParamTraits<ppapi::proxy::SerializedDirEntry>::Read(const Message* m, |
327 void** iter, | 329 PickleIterator* iter, |
328 param_type* r) { | 330 param_type* r) { |
329 return ParamTraits<std::string>::Read(m, iter, &r->name) && | 331 return ParamTraits<std::string>::Read(m, iter, &r->name) && |
330 ParamTraits<bool>::Read(m, iter, &r->is_dir); | 332 ParamTraits<bool>::Read(m, iter, &r->is_dir); |
331 } | 333 } |
332 | 334 |
333 // static | 335 // static |
334 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Log(const param_type& p, | 336 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Log(const param_type& p, |
335 std::string* l) { | 337 std::string* l) { |
336 } | 338 } |
337 | 339 |
338 // ppapi::proxy::SerializedFontDescription ------------------------------------- | 340 // ppapi::proxy::SerializedFontDescription ------------------------------------- |
339 | 341 |
340 // static | 342 // static |
341 void ParamTraits<ppapi::proxy::SerializedFontDescription>::Write( | 343 void ParamTraits<ppapi::proxy::SerializedFontDescription>::Write( |
342 Message* m, | 344 Message* m, |
343 const param_type& p) { | 345 const param_type& p) { |
344 ParamTraits<ppapi::proxy::SerializedVar>::Write(m, p.face); | 346 ParamTraits<ppapi::proxy::SerializedVar>::Write(m, p.face); |
345 ParamTraits<int32_t>::Write(m, p.family); | 347 ParamTraits<int32_t>::Write(m, p.family); |
346 ParamTraits<uint32_t>::Write(m, p.size); | 348 ParamTraits<uint32_t>::Write(m, p.size); |
347 ParamTraits<int32_t>::Write(m, p.weight); | 349 ParamTraits<int32_t>::Write(m, p.weight); |
348 ParamTraits<PP_Bool>::Write(m, p.italic); | 350 ParamTraits<PP_Bool>::Write(m, p.italic); |
349 ParamTraits<PP_Bool>::Write(m, p.small_caps); | 351 ParamTraits<PP_Bool>::Write(m, p.small_caps); |
350 ParamTraits<int32_t>::Write(m, p.letter_spacing); | 352 ParamTraits<int32_t>::Write(m, p.letter_spacing); |
351 ParamTraits<int32_t>::Write(m, p.word_spacing); | 353 ParamTraits<int32_t>::Write(m, p.word_spacing); |
352 } | 354 } |
353 | 355 |
354 // static | 356 // static |
355 bool ParamTraits<ppapi::proxy::SerializedFontDescription>::Read( | 357 bool ParamTraits<ppapi::proxy::SerializedFontDescription>::Read( |
356 const Message* m, | 358 const Message* m, |
357 void** iter, | 359 PickleIterator* iter, |
358 param_type* r) { | 360 param_type* r) { |
359 return | 361 return |
360 ParamTraits<ppapi::proxy::SerializedVar>::Read(m, iter, &r->face) && | 362 ParamTraits<ppapi::proxy::SerializedVar>::Read(m, iter, &r->face) && |
361 ParamTraits<int32_t>::Read(m, iter, &r->family) && | 363 ParamTraits<int32_t>::Read(m, iter, &r->family) && |
362 ParamTraits<uint32_t>::Read(m, iter, &r->size) && | 364 ParamTraits<uint32_t>::Read(m, iter, &r->size) && |
363 ParamTraits<int32_t>::Read(m, iter, &r->weight) && | 365 ParamTraits<int32_t>::Read(m, iter, &r->weight) && |
364 ParamTraits<PP_Bool>::Read(m, iter, &r->italic) && | 366 ParamTraits<PP_Bool>::Read(m, iter, &r->italic) && |
365 ParamTraits<PP_Bool>::Read(m, iter, &r->small_caps) && | 367 ParamTraits<PP_Bool>::Read(m, iter, &r->small_caps) && |
366 ParamTraits<int32_t>::Read(m, iter, &r->letter_spacing) && | 368 ParamTraits<int32_t>::Read(m, iter, &r->letter_spacing) && |
367 ParamTraits<int32_t>::Read(m, iter, &r->word_spacing); | 369 ParamTraits<int32_t>::Read(m, iter, &r->word_spacing); |
368 } | 370 } |
369 | 371 |
370 // static | 372 // static |
371 void ParamTraits<ppapi::proxy::SerializedFontDescription>::Log( | 373 void ParamTraits<ppapi::proxy::SerializedFontDescription>::Log( |
372 const param_type& p, | 374 const param_type& p, |
373 std::string* l) { | 375 std::string* l) { |
374 } | 376 } |
375 | 377 |
376 // HostResource ---------------------------------------------------------------- | 378 // HostResource ---------------------------------------------------------------- |
377 | 379 |
378 // static | 380 // static |
379 void ParamTraits<ppapi::HostResource>::Write(Message* m, | 381 void ParamTraits<ppapi::HostResource>::Write(Message* m, |
380 const param_type& p) { | 382 const param_type& p) { |
381 ParamTraits<PP_Instance>::Write(m, p.instance()); | 383 ParamTraits<PP_Instance>::Write(m, p.instance()); |
382 ParamTraits<PP_Resource>::Write(m, p.host_resource()); | 384 ParamTraits<PP_Resource>::Write(m, p.host_resource()); |
383 } | 385 } |
384 | 386 |
385 // static | 387 // static |
386 bool ParamTraits<ppapi::HostResource>::Read(const Message* m, | 388 bool ParamTraits<ppapi::HostResource>::Read(const Message* m, |
387 void** iter, | 389 PickleIterator* iter, |
388 param_type* r) { | 390 param_type* r) { |
389 PP_Instance instance; | 391 PP_Instance instance; |
390 PP_Resource resource; | 392 PP_Resource resource; |
391 if (!ParamTraits<PP_Instance>::Read(m, iter, &instance) || | 393 if (!ParamTraits<PP_Instance>::Read(m, iter, &instance) || |
392 !ParamTraits<PP_Resource>::Read(m, iter, &resource)) | 394 !ParamTraits<PP_Resource>::Read(m, iter, &resource)) |
393 return false; | 395 return false; |
394 r->SetHostResource(instance, resource); | 396 r->SetHostResource(instance, resource); |
395 return true; | 397 return true; |
396 } | 398 } |
397 | 399 |
398 // static | 400 // static |
399 void ParamTraits<ppapi::HostResource>::Log(const param_type& p, | 401 void ParamTraits<ppapi::HostResource>::Log(const param_type& p, |
400 std::string* l) { | 402 std::string* l) { |
401 } | 403 } |
402 | 404 |
403 // SerializedVar --------------------------------------------------------------- | 405 // SerializedVar --------------------------------------------------------------- |
404 | 406 |
405 // static | 407 // static |
406 void ParamTraits<ppapi::proxy::SerializedVar>::Write(Message* m, | 408 void ParamTraits<ppapi::proxy::SerializedVar>::Write(Message* m, |
407 const param_type& p) { | 409 const param_type& p) { |
408 p.WriteToMessage(m); | 410 p.WriteToMessage(m); |
409 } | 411 } |
410 | 412 |
411 // static | 413 // static |
412 bool ParamTraits<ppapi::proxy::SerializedVar>::Read(const Message* m, | 414 bool ParamTraits<ppapi::proxy::SerializedVar>::Read(const Message* m, |
413 void** iter, | 415 PickleIterator* iter, |
414 param_type* r) { | 416 param_type* r) { |
415 return r->ReadFromMessage(m, iter); | 417 return r->ReadFromMessage(m, iter); |
416 } | 418 } |
417 | 419 |
418 // static | 420 // static |
419 void ParamTraits<ppapi::proxy::SerializedVar>::Log(const param_type& p, | 421 void ParamTraits<ppapi::proxy::SerializedVar>::Log(const param_type& p, |
420 std::string* l) { | 422 std::string* l) { |
421 } | 423 } |
422 | 424 |
423 // std::vector<SerializedVar> -------------------------------------------------- | 425 // std::vector<SerializedVar> -------------------------------------------------- |
424 | 426 |
425 void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Write( | 427 void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Write( |
426 Message* m, | 428 Message* m, |
427 const param_type& p) { | 429 const param_type& p) { |
428 WriteVectorWithoutCopy(m, p); | 430 WriteVectorWithoutCopy(m, p); |
429 } | 431 } |
430 | 432 |
431 // static | 433 // static |
432 bool ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Read( | 434 bool ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Read( |
433 const Message* m, | 435 const Message* m, |
434 void** iter, | 436 PickleIterator* iter, |
435 param_type* r) { | 437 param_type* r) { |
436 return ReadVectorWithoutCopy(m, iter, r); | 438 return ReadVectorWithoutCopy(m, iter, r); |
437 } | 439 } |
438 | 440 |
439 // static | 441 // static |
440 void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Log( | 442 void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Log( |
441 const param_type& p, | 443 const param_type& p, |
442 std::string* l) { | 444 std::string* l) { |
443 } | 445 } |
444 | 446 |
445 // std::vector<PPB_FileRef_CreateInfo> ----------------------------------------- | 447 // std::vector<PPB_FileRef_CreateInfo> ----------------------------------------- |
446 | 448 |
447 void ParamTraits< std::vector<ppapi::PPB_FileRef_CreateInfo> >::Write( | 449 void ParamTraits< std::vector<ppapi::PPB_FileRef_CreateInfo> >::Write( |
448 Message* m, | 450 Message* m, |
449 const param_type& p) { | 451 const param_type& p) { |
450 WriteVectorWithoutCopy(m, p); | 452 WriteVectorWithoutCopy(m, p); |
451 } | 453 } |
452 | 454 |
453 // static | 455 // static |
454 bool ParamTraits< std::vector<ppapi::PPB_FileRef_CreateInfo> >::Read( | 456 bool ParamTraits< std::vector<ppapi::PPB_FileRef_CreateInfo> >::Read( |
455 const Message* m, | 457 const Message* m, |
456 void** iter, | 458 PickleIterator* iter, |
457 param_type* r) { | 459 param_type* r) { |
458 return ReadVectorWithoutCopy(m, iter, r); | 460 return ReadVectorWithoutCopy(m, iter, r); |
459 } | 461 } |
460 | 462 |
461 // static | 463 // static |
462 void ParamTraits< std::vector<ppapi::PPB_FileRef_CreateInfo> >::Log( | 464 void ParamTraits< std::vector<ppapi::PPB_FileRef_CreateInfo> >::Log( |
463 const param_type& p, | 465 const param_type& p, |
464 std::string* l) { | 466 std::string* l) { |
465 } | 467 } |
466 | 468 |
467 // SerializedFlashMenu --------------------------------------------------------- | 469 // SerializedFlashMenu --------------------------------------------------------- |
468 | 470 |
469 // static | 471 // static |
470 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Write( | 472 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Write( |
471 Message* m, | 473 Message* m, |
472 const param_type& p) { | 474 const param_type& p) { |
473 p.WriteToMessage(m); | 475 p.WriteToMessage(m); |
474 } | 476 } |
475 | 477 |
476 // static | 478 // static |
477 bool ParamTraits<ppapi::proxy::SerializedFlashMenu>::Read(const Message* m, | 479 bool ParamTraits<ppapi::proxy::SerializedFlashMenu>::Read(const Message* m, |
478 void** iter, | 480 PickleIterator* iter, |
479 param_type* r) { | 481 param_type* r) { |
480 return r->ReadFromMessage(m, iter); | 482 return r->ReadFromMessage(m, iter); |
481 } | 483 } |
482 | 484 |
483 // static | 485 // static |
484 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Log(const param_type& p, | 486 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Log(const param_type& p, |
485 std::string* l) { | 487 std::string* l) { |
486 } | 488 } |
487 | 489 |
488 } // namespace IPC | 490 } // namespace IPC |
OLD | NEW |