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 "ppapi/proxy/ppapi_param_traits.h" 6 7 #include <string.h> // For memcpy 8 9 #include "ppapi/c/pp_resource.h" 10 #include "ppapi/proxy/ppapi_messages.h" 11 #include "ppapi/proxy/serialized_var.h" 12 #include "ppapi/proxy/serialized_flash_menu.h" 13 #include "ppapi/shared_impl/host_resource.h" 14 #include "ppapi/shared_impl/private/ppb_x509_certificate_private_shared.h" 15 16 namespace IPC { 17 18 namespace { 19 20 // Deserializes a vector from IPC. This special version must be used instead 21 // of the default IPC version when the vector contains a SerializedVar, either 22 // directly or indirectly (i.e. a vector of objects that have a SerializedVar 23 // inside them). 24 // 25 // The default vector deserializer does resize and then we deserialize into 26 // those allocated slots. However, the implementation of vector (at least in 27 // GCC's implementation), creates a new empty object using the default 28 // constructor, and then sets the rest of the items to that empty one using the 29 // copy constructor. 30 // 31 // Since we allocate the inner class when you call the default constructor and 32 // transfer the inner class when you do operator=, the entire vector will end 33 // up referring to the same inner class. Deserializing into this will just end 34 // up overwriting the same item over and over, since all the SerializedVars 35 // will refer to the same thing. 36 // 37 // The solution is to make a new object for each deserialized item, and then 38 // add it to the vector one at a time. 39 template<typename T> 40 bool ReadVectorWithoutCopy(const Message* m, 41 PickleIterator* iter, 42 std::vector<T>* output) { 43 // This part is just a copy of the the default ParamTraits vector Read(). 44 int size; 45 // ReadLength() checks for < 0 itself. 46 if (!m->ReadLength(iter, &size)) 47 return false; 48 // Resizing beforehand is not safe, see BUG 1006367 for details. 49 if (INT_MAX / sizeof(T) <= static_cast<size_t>(size)) 50 return false; 51 52 output->reserve(size); 53 for (int i = 0; i < size; i++) { 54 T cur; 55 if (!ReadParam(m, iter, &cur)) 56 return false; 57 output->push_back(cur); 58 } 59 return true; 60 } 61 62 // This serializes the vector of items to the IPC message in exactly the same 63 // way as the "regular" IPC vector serializer does. But having the code here 64 // saves us from having to copy this code into all ParamTraits that use the 65 // ReadVectorWithoutCopy function for deserializing. 66 template<typename T> 67 void WriteVectorWithoutCopy(Message* m, const std::vector<T>& p) { 68 WriteParam(m, static_cast<int>(p.size())); 69 for (size_t i = 0; i < p.size(); i++) 70 WriteParam(m, p[i]); 71 } 72 73 } // namespace 74 75 // PP_Bool --------------------------------------------------------------------- 76 77 // static 78 void ParamTraits<PP_Bool>::Write(Message* m, const param_type& p) { 79 ParamTraits<bool>::Write(m, PP_ToBool(p)); 80 } 81 82 // static 83 bool ParamTraits<PP_Bool>::Read(const Message* m, 84 PickleIterator* iter, 85 param_type* r) { 86 // We specifically want to be strict here about what types of input we accept, 87 // which ParamTraits<bool> does for us. We don't want to deserialize "2" into 88 // a PP_Bool, for example. 89 bool result = false; 90 if (!ParamTraits<bool>::Read(m, iter, &result)) 91 return false; 92 *r = PP_FromBool(result); 93 return true; 94 } 95 96 // static 97 void ParamTraits<PP_Bool>::Log(const param_type& p, std::string* l) { 98 } 99 100 // PP_NetAddress_Private ------------------------------------------------------- 101 102 // static 103 void ParamTraits<PP_NetAddress_Private>::Write(Message* m, 104 const param_type& p) { 105 WriteParam(m, p.size); 106 m->WriteBytes(p.data, static_cast<int>(p.size)); 107 } 108 109 // static 110 bool ParamTraits<PP_NetAddress_Private>::Read(const Message* m, 111 PickleIterator* iter, 112 param_type* p) { 113 uint16 size; 114 if (!ReadParam(m, iter, &size)) 115 return false; 116 if (size > sizeof(p->data)) 117 return false; 118 p->size = size; 119 120 const char* data; 121 if (!m->ReadBytes(iter, &data, size)) 122 return false; 123 memcpy(p->data, data, size); 124 return true; 125 } 126 127 // static 128 void ParamTraits<PP_NetAddress_Private>::Log(const param_type& p, 129 std::string* l) { 130 l->append("<PP_NetAddress_Private ("); 131 LogParam(p.size, l); 132 l->append(" bytes)>"); 133 } 134 135 // HostResource ---------------------------------------------------------------- 136 137 // static 138 void ParamTraits<ppapi::HostResource>::Write(Message* m, 139 const param_type& p) { 140 ParamTraits<PP_Instance>::Write(m, p.instance()); 141 ParamTraits<PP_Resource>::Write(m, p.host_resource()); 142 } 143 144 // static 145 bool ParamTraits<ppapi::HostResource>::Read(const Message* m, 146 PickleIterator* iter, 147 param_type* r) { 148 PP_Instance instance; 149 PP_Resource resource; 150 if (!ParamTraits<PP_Instance>::Read(m, iter, &instance) || 151 !ParamTraits<PP_Resource>::Read(m, iter, &resource)) 152 return false; 153 r->SetHostResource(instance, resource); 154 return true; 155 } 156 157 // static 158 void ParamTraits<ppapi::HostResource>::Log(const param_type& p, 159 std::string* l) { 160 } 161 162 // SerializedVar --------------------------------------------------------------- 163 164 // static 165 void ParamTraits<ppapi::proxy::SerializedVar>::Write(Message* m, 166 const param_type& p) { 167 p.WriteToMessage(m); 168 } 169 170 // static 171 bool ParamTraits<ppapi::proxy::SerializedVar>::Read(const Message* m, 172 PickleIterator* iter, 173 param_type* r) { 174 return r->ReadFromMessage(m, iter); 175 } 176 177 // static 178 void ParamTraits<ppapi::proxy::SerializedVar>::Log(const param_type& p, 179 std::string* l) { 180 } 181 182 // std::vector<SerializedVar> -------------------------------------------------- 183 184 void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Write( 185 Message* m, 186 const param_type& p) { 187 WriteVectorWithoutCopy(m, p); 188 } 189 190 // static 191 bool ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Read( 192 const Message* m, 193 PickleIterator* iter, 194 param_type* r) { 195 return ReadVectorWithoutCopy(m, iter, r); 196 } 197 198 // static 199 void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Log( 200 const param_type& p, 201 std::string* l) { 202 } 203 204 // ppapi::PpapiPermissions ----------------------------------------------------- 205 206 void ParamTraits<ppapi::PpapiPermissions>::Write(Message* m, 207 const param_type& p) { 208 ParamTraits<uint32_t>::Write(m, p.GetBits()); 209 } 210 211 // static 212 bool ParamTraits<ppapi::PpapiPermissions>::Read(const Message* m, 213 PickleIterator* iter, 214 param_type* r) { 215 uint32_t bits; 216 if (!ParamTraits<uint32_t>::Read(m, iter, &bits)) 217 return false; 218 *r = ppapi::PpapiPermissions(bits); 219 return true; 220 } 221 222 // static 223 void ParamTraits<ppapi::PpapiPermissions>::Log(const param_type& p, 224 std::string* l) { 225 } 226 227 // SerializedHandle ------------------------------------------------------------ 228 229 // static 230 void ParamTraits<ppapi::proxy::SerializedHandle>::Write(Message* m, 231 const param_type& p) { 232 ppapi::proxy::SerializedHandle::WriteHeader(p.header(), m); 233 switch (p.type()) { 234 case ppapi::proxy::SerializedHandle::SHARED_MEMORY: 235 ParamTraits<base::SharedMemoryHandle>::Write(m, p.shmem()); 236 break; 237 case ppapi::proxy::SerializedHandle::SOCKET: 238 case ppapi::proxy::SerializedHandle::FILE: 239 ParamTraits<IPC::PlatformFileForTransit>::Write(m, p.descriptor()); 240 break; 241 case ppapi::proxy::SerializedHandle::INVALID: 242 break; 243 // No default so the compiler will warn on new types. 244 } 245 } 246 247 // static 248 bool ParamTraits<ppapi::proxy::SerializedHandle>::Read(const Message* m, 249 PickleIterator* iter, 250 param_type* r) { 251 ppapi::proxy::SerializedHandle::Header header; 252 if (!ppapi::proxy::SerializedHandle::ReadHeader(iter, &header)) 253 return false; 254 switch (header.type) { 255 case ppapi::proxy::SerializedHandle::SHARED_MEMORY: { 256 base::SharedMemoryHandle handle; 257 if (ParamTraits<base::SharedMemoryHandle>::Read(m, iter, &handle)) { 258 r->set_shmem(handle, header.size); 259 return true; 260 } 261 break; 262 } 263 case ppapi::proxy::SerializedHandle::SOCKET: { 264 IPC::PlatformFileForTransit socket; 265 if (ParamTraits<IPC::PlatformFileForTransit>::Read(m, iter, &socket)) { 266 r->set_socket(socket); 267 return true; 268 } 269 break; 270 } 271 case ppapi::proxy::SerializedHandle::FILE: { 272 IPC::PlatformFileForTransit desc; 273 if (ParamTraits<IPC::PlatformFileForTransit>::Read(m, iter, &desc)) { 274 r->set_file_handle(desc, header.open_flags, header.file_io); 275 return true; 276 } 277 break; 278 } 279 case ppapi::proxy::SerializedHandle::INVALID: 280 return true; 281 // No default so the compiler will warn us if a new type is added. 282 } 283 return false; 284 } 285 286 // static 287 void ParamTraits<ppapi::proxy::SerializedHandle>::Log(const param_type& p, 288 std::string* l) { 289 } 290 291 // PPBURLLoader_UpdateProgress_Params ------------------------------------------ 292 293 // static 294 void ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Write( 295 Message* m, 296 const param_type& p) { 297 ParamTraits<PP_Instance>::Write(m, p.instance); 298 ParamTraits<ppapi::HostResource>::Write(m, p.resource); 299 ParamTraits<int64_t>::Write(m, p.bytes_sent); 300 ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_sent); 301 ParamTraits<int64_t>::Write(m, p.bytes_received); 302 ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_received); 303 } 304 305 // static 306 bool ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Read( 307 const Message* m, 308 PickleIterator* iter, 309 param_type* r) { 310 return 311 ParamTraits<PP_Instance>::Read(m, iter, &r->instance) && 312 ParamTraits<ppapi::HostResource>::Read(m, iter, &r->resource) && 313 ParamTraits<int64_t>::Read(m, iter, &r->bytes_sent) && 314 ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_sent) && 315 ParamTraits<int64_t>::Read(m, iter, &r->bytes_received) && 316 ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_received); 317 } 318 319 // static 320 void ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Log( 321 const param_type& p, 322 std::string* l) { 323 } 324 325 #if !defined(OS_NACL) && !defined(NACL_WIN64) 326 // PPBFlash_DrawGlyphs_Params -------------------------------------------------- 327 // static 328 void ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Write( 329 Message* m, 330 const param_type& p) { 331 ParamTraits<PP_Instance>::Write(m, p.instance); 332 ParamTraits<ppapi::HostResource>::Write(m, p.image_data); 333 ParamTraits<ppapi::proxy::SerializedFontDescription>::Write(m, p.font_desc); 334 ParamTraits<uint32_t>::Write(m, p.color); 335 ParamTraits<PP_Point>::Write(m, p.position); 336 ParamTraits<PP_Rect>::Write(m, p.clip); 337 ParamTraits<float>::Write(m, p.transformation[0][0]); 338 ParamTraits<float>::Write(m, p.transformation[0][1]); 339 ParamTraits<float>::Write(m, p.transformation[0][2]); 340 ParamTraits<float>::Write(m, p.transformation[1][0]); 341 ParamTraits<float>::Write(m, p.transformation[1][1]); 342 ParamTraits<float>::Write(m, p.transformation[1][2]); 343 ParamTraits<float>::Write(m, p.transformation[2][0]); 344 ParamTraits<float>::Write(m, p.transformation[2][1]); 345 ParamTraits<float>::Write(m, p.transformation[2][2]); 346 ParamTraits<PP_Bool>::Write(m, p.allow_subpixel_aa); 347 ParamTraits<std::vector<uint16_t> >::Write(m, p.glyph_indices); 348 ParamTraits<std::vector<PP_Point> >::Write(m, p.glyph_advances); 349 } 350 351 // static 352 bool ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Read( 353 const Message* m, 354 PickleIterator* iter, 355 param_type* r) { 356 return 357 ParamTraits<PP_Instance>::Read(m, iter, &r->instance) && 358 ParamTraits<ppapi::HostResource>::Read(m, iter, &r->image_data) && 359 ParamTraits<ppapi::proxy::SerializedFontDescription>::Read(m, iter, 360 &r->font_desc) && 361 ParamTraits<uint32_t>::Read(m, iter, &r->color) && 362 ParamTraits<PP_Point>::Read(m, iter, &r->position) && 363 ParamTraits<PP_Rect>::Read(m, iter, &r->clip) && 364 ParamTraits<float>::Read(m, iter, &r->transformation[0][0]) && 365 ParamTraits<float>::Read(m, iter, &r->transformation[0][1]) && 366 ParamTraits<float>::Read(m, iter, &r->transformation[0][2]) && 367 ParamTraits<float>::Read(m, iter, &r->transformation[1][0]) && 368 ParamTraits<float>::Read(m, iter, &r->transformation[1][1]) && 369 ParamTraits<float>::Read(m, iter, &r->transformation[1][2]) && 370 ParamTraits<float>::Read(m, iter, &r->transformation[2][0]) && 371 ParamTraits<float>::Read(m, iter, &r->transformation[2][1]) && 372 ParamTraits<float>::Read(m, iter, &r->transformation[2][2]) && 373 ParamTraits<PP_Bool>::Read(m, iter, &r->allow_subpixel_aa) && 374 ParamTraits<std::vector<uint16_t> >::Read(m, iter, &r->glyph_indices) && 375 ParamTraits<std::vector<PP_Point> >::Read(m, iter, &r->glyph_advances) && 376 r->glyph_indices.size() == r->glyph_advances.size(); 377 } 378 379 // static 380 void ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Log( 381 const param_type& p, 382 std::string* l) { 383 } 384 385 // SerializedDirEntry ---------------------------------------------------------- 386 387 // static 388 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Write(Message* m, 389 const param_type& p) { 390 ParamTraits<std::string>::Write(m, p.name); 391 ParamTraits<bool>::Write(m, p.is_dir); 392 } 393 394 // static 395 bool ParamTraits<ppapi::proxy::SerializedDirEntry>::Read(const Message* m, 396 PickleIterator* iter, 397 param_type* r) { 398 return ParamTraits<std::string>::Read(m, iter, &r->name) && 399 ParamTraits<bool>::Read(m, iter, &r->is_dir); 400 } 401 402 // static 403 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Log(const param_type& p, 404 std::string* l) { 405 } 406 407 // ppapi::proxy::SerializedFontDescription ------------------------------------- 408 409 // static 410 void ParamTraits<ppapi::proxy::SerializedFontDescription>::Write( 411 Message* m, 412 const param_type& p) { 413 ParamTraits<std::string>::Write(m, p.face); 414 ParamTraits<int32_t>::Write(m, p.family); 415 ParamTraits<uint32_t>::Write(m, p.size); 416 ParamTraits<int32_t>::Write(m, p.weight); 417 ParamTraits<PP_Bool>::Write(m, p.italic); 418 ParamTraits<PP_Bool>::Write(m, p.small_caps); 419 ParamTraits<int32_t>::Write(m, p.letter_spacing); 420 ParamTraits<int32_t>::Write(m, p.word_spacing); 421 } 422 423 // static 424 bool ParamTraits<ppapi::proxy::SerializedFontDescription>::Read( 425 const Message* m, 426 PickleIterator* iter, 427 param_type* r) { 428 return 429 ParamTraits<std::string>::Read(m, iter, &r->face) && 430 ParamTraits<int32_t>::Read(m, iter, &r->family) && 431 ParamTraits<uint32_t>::Read(m, iter, &r->size) && 432 ParamTraits<int32_t>::Read(m, iter, &r->weight) && 433 ParamTraits<PP_Bool>::Read(m, iter, &r->italic) && 434 ParamTraits<PP_Bool>::Read(m, iter, &r->small_caps) && 435 ParamTraits<int32_t>::Read(m, iter, &r->letter_spacing) && 436 ParamTraits<int32_t>::Read(m, iter, &r->word_spacing); 437 } 438 439 // static 440 void ParamTraits<ppapi::proxy::SerializedFontDescription>::Log( 441 const param_type& p, 442 std::string* l) { 443 } 444 #endif // !defined(OS_NACL) && !defined(NACL_WIN64) 445 446 // ppapi::proxy::SerializedTrueTypeFontDesc ------------------------------------ 447 448 // static 449 void ParamTraits<ppapi::proxy::SerializedTrueTypeFontDesc>::Write( 450 Message* m, 451 const param_type& p) { 452 ParamTraits<std::string>::Write(m, p.family); 453 ParamTraits<PP_TrueTypeFontFamily_Dev>::Write(m, p.generic_family); 454 ParamTraits<PP_TrueTypeFontStyle_Dev>::Write(m, p.style); 455 ParamTraits<PP_TrueTypeFontWeight_Dev>::Write(m, p.weight); 456 ParamTraits<PP_TrueTypeFontWidth_Dev>::Write(m, p.width); 457 ParamTraits<PP_TrueTypeFontCharset_Dev>::Write(m, p.charset); 458 } 459 460 // static 461 bool ParamTraits<ppapi::proxy::SerializedTrueTypeFontDesc>::Read( 462 const Message* m, 463 PickleIterator* iter, 464 param_type* r) { 465 return 466 ParamTraits<std::string>::Read(m, iter, &r->family) && 467 ParamTraits<PP_TrueTypeFontFamily_Dev>::Read(m, iter, 468 &r->generic_family) && 469 ParamTraits<PP_TrueTypeFontStyle_Dev>::Read(m, iter, &r->style) && 470 ParamTraits<PP_TrueTypeFontWeight_Dev>::Read(m, iter, &r->weight) && 471 ParamTraits<PP_TrueTypeFontWidth_Dev>::Read(m, iter, &r->width) && 472 ParamTraits<PP_TrueTypeFontCharset_Dev>::Read(m, iter, &r->charset); 473 } 474 475 // static 476 void ParamTraits<ppapi::proxy::SerializedTrueTypeFontDesc>::Log( 477 const param_type& p, 478 std::string* l) { 479 } 480 481 #if !defined(OS_NACL) && !defined(NACL_WIN64) 482 // ppapi::PepperFilePath ------------------------------------------------------- 483 484 // static 485 void ParamTraits<ppapi::PepperFilePath>::Write(Message* m, 486 const param_type& p) { 487 WriteParam(m, static_cast<unsigned>(p.domain())); 488 WriteParam(m, p.path()); 489 } 490 491 // static 492 bool ParamTraits<ppapi::PepperFilePath>::Read(const Message* m, 493 PickleIterator* iter, 494 param_type* p) { 495 unsigned domain; 496 base::FilePath path; 497 if (!ReadParam(m, iter, &domain) || !ReadParam(m, iter, &path)) 498 return false; 499 if (domain > ppapi::PepperFilePath::DOMAIN_MAX_VALID) 500 return false; 501 502 *p = ppapi::PepperFilePath( 503 static_cast<ppapi::PepperFilePath::Domain>(domain), path); 504 return true; 505 } 506 507 // static 508 void ParamTraits<ppapi::PepperFilePath>::Log(const param_type& p, 509 std::string* l) { 510 l->append("("); 511 LogParam(static_cast<unsigned>(p.domain()), l); 512 l->append(", "); 513 LogParam(p.path(), l); 514 l->append(")"); 515 } 516 517 // SerializedFlashMenu --------------------------------------------------------- 518 519 // static 520 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Write( 521 Message* m, 522 const param_type& p) { 523 p.WriteToMessage(m); 524 } 525 526 // static 527 bool ParamTraits<ppapi::proxy::SerializedFlashMenu>::Read(const Message* m, 528 PickleIterator* iter, 529 param_type* r) { 530 return r->ReadFromMessage(m, iter); 531 } 532 533 // static 534 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Log(const param_type& p, 535 std::string* l) { 536 } 537 #endif // !defined(OS_NACL) && !defined(NACL_WIN64) 538 539 // PPB_X509Certificate_Fields -------------------------------------------------- 540 541 // static 542 void ParamTraits<ppapi::PPB_X509Certificate_Fields>::Write( 543 Message* m, 544 const param_type& p) { 545 ParamTraits<base::ListValue>::Write(m, p.values_); 546 } 547 548 // static 549 bool ParamTraits<ppapi::PPB_X509Certificate_Fields>::Read(const Message* m, 550 PickleIterator* iter, 551 param_type* r) { 552 return ParamTraits<base::ListValue>::Read(m, iter, &(r->values_)); 553 } 554 555 // static 556 void ParamTraits<ppapi::PPB_X509Certificate_Fields>::Log(const param_type& p, 557 std::string* l) { 558 } 559 560 // ppapi::SocketOptionData ----------------------------------------------------- 561 562 // static 563 void ParamTraits<ppapi::SocketOptionData>::Write(Message* m, 564 const param_type& p) { 565 ppapi::SocketOptionData::Type type = p.GetType(); 566 ParamTraits<int32_t>::Write(m, static_cast<int32_t>(type)); 567 switch (type) { 568 case ppapi::SocketOptionData::TYPE_INVALID: { 569 break; 570 } 571 case ppapi::SocketOptionData::TYPE_BOOL: { 572 bool out_value = false; 573 bool result = p.GetBool(&out_value); 574 // Suppress unused variable warnings. 575 static_cast<void>(result); 576 DCHECK(result); 577 578 ParamTraits<bool>::Write(m, out_value); 579 break; 580 } 581 case ppapi::SocketOptionData::TYPE_INT32: { 582 int32_t out_value = 0; 583 bool result = p.GetInt32(&out_value); 584 // Suppress unused variable warnings. 585 static_cast<void>(result); 586 DCHECK(result); 587 588 ParamTraits<int32_t>::Write(m, out_value); 589 break; 590 } 591 // No default so the compiler will warn on new types. 592 } 593 } 594 595 // static 596 bool ParamTraits<ppapi::SocketOptionData>::Read(const Message* m, 597 PickleIterator* iter, 598 param_type* r) { 599 *r = ppapi::SocketOptionData(); 600 int32_t type = 0; 601 if (!ParamTraits<int32_t>::Read(m, iter, &type)) 602 return false; 603 if (type != ppapi::SocketOptionData::TYPE_INVALID && 604 type != ppapi::SocketOptionData::TYPE_BOOL && 605 type != ppapi::SocketOptionData::TYPE_INT32) { 606 return false; 607 } 608 switch (static_cast<ppapi::SocketOptionData::Type>(type)) { 609 case ppapi::SocketOptionData::TYPE_INVALID: { 610 return true; 611 } 612 case ppapi::SocketOptionData::TYPE_BOOL: { 613 bool value = false; 614 if (!ParamTraits<bool>::Read(m, iter, &value)) 615 return false; 616 r->SetBool(value); 617 return true; 618 } 619 case ppapi::SocketOptionData::TYPE_INT32: { 620 int32_t value = 0; 621 if (!ParamTraits<int32_t>::Read(m, iter, &value)) 622 return false; 623 r->SetInt32(value); 624 return true; 625 } 626 // No default so the compiler will warn on new types. 627 } 628 return false; 629 } 630 631 // static 632 void ParamTraits<ppapi::SocketOptionData>::Log(const param_type& p, 633 std::string* l) { 634 } 635 636 // ppapi::CompositorLayerData -------------------------------------------------- 637 638 // static 639 void ParamTraits<ppapi::CompositorLayerData::Transform>::Write( 640 Message* m, 641 const param_type& p) { 642 for (size_t i = 0; i < arraysize(p.matrix); i++) 643 ParamTraits<float>::Write(m, p.matrix[i]); 644 } 645 646 // static 647 bool ParamTraits<ppapi::CompositorLayerData::Transform>::Read( 648 const Message* m, 649 PickleIterator* iter, 650 param_type* r) { 651 for (size_t i = 0; i < arraysize(r->matrix);i++) { 652 if (!ParamTraits<float>::Read(m, iter, &r->matrix[i])) 653 return false; 654 } 655 return true; 656 } 657 658 void ParamTraits<ppapi::CompositorLayerData::Transform>::Log( 659 const param_type& p, 660 std::string* l) { 661 } 662 663 } // namespace IPC 664
