ppapi/proxy/ppapi_param_traits.cc

   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::CHANNEL_HANDLE:
 239     case ppapi::proxy::SerializedHandle::FILE:
 240       ParamTraits<IPC::PlatformFileForTransit>::Write(m, p.descriptor());
 241       break;
 242     case ppapi::proxy::SerializedHandle::INVALID:
 243       break;
 244     // No default so the compiler will warn on new types.
 245   }
 246 }
 247
 248 // static
 249 bool ParamTraits<ppapi::proxy::SerializedHandle>::Read(const Message* m,
 250                                                        PickleIterator* iter,
 251                                                        param_type* r) {
 252   ppapi::proxy::SerializedHandle::Header header;
 253   if (!ppapi::proxy::SerializedHandle::ReadHeader(iter, &header))
 254     return false;
 255   switch (header.type) {
 256     case ppapi::proxy::SerializedHandle::SHARED_MEMORY: {
 257       base::SharedMemoryHandle handle;
 258       if (ParamTraits<base::SharedMemoryHandle>::Read(m, iter, &handle)) {
 259         r->set_shmem(handle, header.size);
 260         return true;
 261       }
 262       break;
 263     }
 264     case ppapi::proxy::SerializedHandle::SOCKET: {
 265       IPC::PlatformFileForTransit socket;
 266       if (ParamTraits<IPC::PlatformFileForTransit>::Read(m, iter, &socket)) {
 267         r->set_socket(socket);
 268         return true;
 269       }
 270       break;
 271     }
 272     case ppapi::proxy::SerializedHandle::CHANNEL_HANDLE: {
 273       IPC::PlatformFileForTransit desc;
 274       if (ParamTraits<IPC::PlatformFileForTransit>::Read(m, iter, &desc)) {
 275         r->set_channel_handle(desc);
 276         return true;
 277       }
 278       break;
 279     }
 280     case ppapi::proxy::SerializedHandle::FILE: {
 281       IPC::PlatformFileForTransit desc;
 282       if (ParamTraits<IPC::PlatformFileForTransit>::Read(m, iter, &desc)) {
 283         r->set_file_handle(desc, header.open_flag);
 284         return true;
 285       }
 286       break;
 287     }
 288     case ppapi::proxy::SerializedHandle::INVALID:
 289       return true;
 290     // No default so the compiler will warn us if a new type is added.
 291   }
 292   return false;
 293 }
 294
 295 // static
 296 void ParamTraits<ppapi::proxy::SerializedHandle>::Log(const param_type& p,
 297                                                       std::string* l) {
 298 }
 299
 300 // PPBURLLoader_UpdateProgress_Params ------------------------------------------
 301
 302 // static
 303 void ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Write(
 304     Message* m,
 305     const param_type& p) {
 306   ParamTraits<PP_Instance>::Write(m, p.instance);
 307   ParamTraits<ppapi::HostResource>::Write(m, p.resource);
 308   ParamTraits<int64_t>::Write(m, p.bytes_sent);
 309   ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_sent);
 310   ParamTraits<int64_t>::Write(m, p.bytes_received);
 311   ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_received);
 312 }
 313
 314 // static
 315 bool ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Read(
 316     const Message* m,
 317     PickleIterator* iter,
 318     param_type* r) {
 319   return
 320       ParamTraits<PP_Instance>::Read(m, iter, &r->instance) &&
 321       ParamTraits<ppapi::HostResource>::Read(m, iter, &r->resource) &&
 322       ParamTraits<int64_t>::Read(m, iter, &r->bytes_sent) &&
 323       ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_sent) &&
 324       ParamTraits<int64_t>::Read(m, iter, &r->bytes_received) &&
 325       ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_received);
 326 }
 327
 328 // static
 329 void ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Log(
 330     const param_type& p,
 331     std::string* l) {
 332 }
 333
 334 #if !defined(OS_NACL) && !defined(NACL_WIN64)
 335 // PPBFlash_DrawGlyphs_Params --------------------------------------------------
 336 // static
 337 void ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Write(
 338     Message* m,
 339     const param_type& p) {
 340   ParamTraits<PP_Instance>::Write(m, p.instance);
 341   ParamTraits<ppapi::HostResource>::Write(m, p.image_data);
 342   ParamTraits<ppapi::proxy::SerializedFontDescription>::Write(m, p.font_desc);
 343   ParamTraits<uint32_t>::Write(m, p.color);
 344   ParamTraits<PP_Point>::Write(m, p.position);
 345   ParamTraits<PP_Rect>::Write(m, p.clip);
 346   ParamTraits<float>::Write(m, p.transformation[0][0]);
 347   ParamTraits<float>::Write(m, p.transformation[0][1]);
 348   ParamTraits<float>::Write(m, p.transformation[0][2]);
 349   ParamTraits<float>::Write(m, p.transformation[1][0]);
 350   ParamTraits<float>::Write(m, p.transformation[1][1]);
 351   ParamTraits<float>::Write(m, p.transformation[1][2]);
 352   ParamTraits<float>::Write(m, p.transformation[2][0]);
 353   ParamTraits<float>::Write(m, p.transformation[2][1]);
 354   ParamTraits<float>::Write(m, p.transformation[2][2]);
 355   ParamTraits<PP_Bool>::Write(m, p.allow_subpixel_aa);
 356   ParamTraits<std::vector<uint16_t> >::Write(m, p.glyph_indices);
 357   ParamTraits<std::vector<PP_Point> >::Write(m, p.glyph_advances);
 358 }
 359
 360 // static
 361 bool ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Read(
 362     const Message* m,
 363     PickleIterator* iter,
 364     param_type* r) {
 365   return
 366       ParamTraits<PP_Instance>::Read(m, iter, &r->instance) &&
 367       ParamTraits<ppapi::HostResource>::Read(m, iter, &r->image_data) &&
 368       ParamTraits<ppapi::proxy::SerializedFontDescription>::Read(m, iter,
 369                                                               &r->font_desc) &&
 370       ParamTraits<uint32_t>::Read(m, iter, &r->color) &&
 371       ParamTraits<PP_Point>::Read(m, iter, &r->position) &&
 372       ParamTraits<PP_Rect>::Read(m, iter, &r->clip) &&
 373       ParamTraits<float>::Read(m, iter, &r->transformation[0][0]) &&
 374       ParamTraits<float>::Read(m, iter, &r->transformation[0][1]) &&
 375       ParamTraits<float>::Read(m, iter, &r->transformation[0][2]) &&
 376       ParamTraits<float>::Read(m, iter, &r->transformation[1][0]) &&
 377       ParamTraits<float>::Read(m, iter, &r->transformation[1][1]) &&
 378       ParamTraits<float>::Read(m, iter, &r->transformation[1][2]) &&
 379       ParamTraits<float>::Read(m, iter, &r->transformation[2][0]) &&
 380       ParamTraits<float>::Read(m, iter, &r->transformation[2][1]) &&
 381       ParamTraits<float>::Read(m, iter, &r->transformation[2][2]) &&
 382       ParamTraits<PP_Bool>::Read(m, iter, &r->allow_subpixel_aa) &&
 383       ParamTraits<std::vector<uint16_t> >::Read(m, iter, &r->glyph_indices) &&
 384       ParamTraits<std::vector<PP_Point> >::Read(m, iter, &r->glyph_advances) &&
 385       r->glyph_indices.size() == r->glyph_advances.size();
 386 }
 387
 388 // static
 389 void ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Log(
 390     const param_type& p,
 391     std::string* l) {
 392 }
 393
 394 // SerializedDirEntry ----------------------------------------------------------
 395
 396 // static
 397 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Write(Message* m,
 398                                                           const param_type& p) {
 399   ParamTraits<std::string>::Write(m, p.name);
 400   ParamTraits<bool>::Write(m, p.is_dir);
 401 }
 402
 403 // static
 404 bool ParamTraits<ppapi::proxy::SerializedDirEntry>::Read(const Message* m,
 405                                                          PickleIterator* iter,
 406                                                          param_type* r) {
 407   return ParamTraits<std::string>::Read(m, iter, &r->name) &&
 408          ParamTraits<bool>::Read(m, iter, &r->is_dir);
 409 }
 410
 411 // static
 412 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Log(const param_type& p,
 413                                                         std::string* l) {
 414 }
 415
 416 // ppapi::proxy::SerializedFontDescription -------------------------------------
 417
 418 // static
 419 void ParamTraits<ppapi::proxy::SerializedFontDescription>::Write(
 420     Message* m,
 421     const param_type& p) {
 422   ParamTraits<std::string>::Write(m, p.face);
 423   ParamTraits<int32_t>::Write(m, p.family);
 424   ParamTraits<uint32_t>::Write(m, p.size);
 425   ParamTraits<int32_t>::Write(m, p.weight);
 426   ParamTraits<PP_Bool>::Write(m, p.italic);
 427   ParamTraits<PP_Bool>::Write(m, p.small_caps);
 428   ParamTraits<int32_t>::Write(m, p.letter_spacing);
 429   ParamTraits<int32_t>::Write(m, p.word_spacing);
 430 }
 431
 432 // static
 433 bool ParamTraits<ppapi::proxy::SerializedFontDescription>::Read(
 434     const Message* m,
 435     PickleIterator* iter,
 436     param_type* r) {
 437   return
 438       ParamTraits<std::string>::Read(m, iter, &r->face) &&
 439       ParamTraits<int32_t>::Read(m, iter, &r->family) &&
 440       ParamTraits<uint32_t>::Read(m, iter, &r->size) &&
 441       ParamTraits<int32_t>::Read(m, iter, &r->weight) &&
 442       ParamTraits<PP_Bool>::Read(m, iter, &r->italic) &&
 443       ParamTraits<PP_Bool>::Read(m, iter, &r->small_caps) &&
 444       ParamTraits<int32_t>::Read(m, iter, &r->letter_spacing) &&
 445       ParamTraits<int32_t>::Read(m, iter, &r->word_spacing);
 446 }
 447
 448 // static
 449 void ParamTraits<ppapi::proxy::SerializedFontDescription>::Log(
 450     const param_type& p,
 451     std::string* l) {
 452 }
 453 #endif  // !defined(OS_NACL) && !defined(NACL_WIN64)
 454
 455 // ppapi::proxy::SerializedTrueTypeFontDesc ------------------------------------
 456
 457 // static
 458 void ParamTraits<ppapi::proxy::SerializedTrueTypeFontDesc>::Write(
 459     Message* m,
 460     const param_type& p) {
 461   ParamTraits<std::string>::Write(m, p.family);
 462   ParamTraits<PP_TrueTypeFontFamily_Dev>::Write(m, p.generic_family);
 463   ParamTraits<PP_TrueTypeFontStyle_Dev>::Write(m, p.style);
 464   ParamTraits<PP_TrueTypeFontWeight_Dev>::Write(m, p.weight);
 465   ParamTraits<PP_TrueTypeFontWidth_Dev>::Write(m, p.width);
 466   ParamTraits<PP_TrueTypeFontCharset_Dev>::Write(m, p.charset);
 467 }
 468
 469 // static
 470 bool ParamTraits<ppapi::proxy::SerializedTrueTypeFontDesc>::Read(
 471     const Message* m,
 472     PickleIterator* iter,
 473     param_type* r) {
 474   return
 475       ParamTraits<std::string>::Read(m, iter, &r->family) &&
 476       ParamTraits<PP_TrueTypeFontFamily_Dev>::Read(m, iter,
 477                                                    &r->generic_family) &&
 478       ParamTraits<PP_TrueTypeFontStyle_Dev>::Read(m, iter, &r->style) &&
 479       ParamTraits<PP_TrueTypeFontWeight_Dev>::Read(m, iter, &r->weight) &&
 480       ParamTraits<PP_TrueTypeFontWidth_Dev>::Read(m, iter, &r->width) &&
 481       ParamTraits<PP_TrueTypeFontCharset_Dev>::Read(m, iter, &r->charset);
 482 }
 483
 484 // static
 485 void ParamTraits<ppapi::proxy::SerializedTrueTypeFontDesc>::Log(
 486     const param_type& p,
 487     std::string* l) {
 488 }
 489
 490 #if !defined(OS_NACL) && !defined(NACL_WIN64)
 491 // ppapi::PepperFilePath -------------------------------------------------------
 492
 493 // static
 494 void ParamTraits<ppapi::PepperFilePath>::Write(Message* m,
 495                                                const param_type& p) {
 496   WriteParam(m, static_cast<unsigned>(p.domain()));
 497   WriteParam(m, p.path());
 498 }
 499
 500 // static
 501 bool ParamTraits<ppapi::PepperFilePath>::Read(const Message* m,
 502                                               PickleIterator* iter,
 503                                               param_type* p) {
 504   unsigned domain;
 505   base::FilePath path;
 506   if (!ReadParam(m, iter, &domain) || !ReadParam(m, iter, &path))
 507     return false;
 508   if (domain > ppapi::PepperFilePath::DOMAIN_MAX_VALID)
 509     return false;
 510
 511   *p = ppapi::PepperFilePath(
 512       static_cast<ppapi::PepperFilePath::Domain>(domain), path);
 513   return true;
 514 }
 515
 516 // static
 517 void ParamTraits<ppapi::PepperFilePath>::Log(const param_type& p,
 518                                              std::string* l) {
 519   l->append("(");
 520   LogParam(static_cast<unsigned>(p.domain()), l);
 521   l->append(", ");
 522   LogParam(p.path(), l);
 523   l->append(")");
 524 }
 525
 526 // SerializedFlashMenu ---------------------------------------------------------
 527
 528 // static
 529 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Write(
 530     Message* m,
 531     const param_type& p) {
 532   p.WriteToMessage(m);
 533 }
 534
 535 // static
 536 bool ParamTraits<ppapi::proxy::SerializedFlashMenu>::Read(const Message* m,
 537                                                           PickleIterator* iter,
 538                                                           param_type* r) {
 539   return r->ReadFromMessage(m, iter);
 540 }
 541
 542 // static
 543 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Log(const param_type& p,
 544                                                          std::string* l) {
 545 }
 546 #endif  // !defined(OS_NACL) && !defined(NACL_WIN64)
 547
 548 // PPB_X509Certificate_Fields --------------------------------------------------
 549
 550 // static
 551 void ParamTraits<ppapi::PPB_X509Certificate_Fields>::Write(
 552     Message* m,
 553     const param_type& p) {
 554   ParamTraits<base::ListValue>::Write(m, p.values_);
 555 }
 556
 557 // static
 558 bool ParamTraits<ppapi::PPB_X509Certificate_Fields>::Read(const Message* m,
 559                                                           PickleIterator* iter,
 560                                                           param_type* r) {
 561   return ParamTraits<base::ListValue>::Read(m, iter, &(r->values_));
 562 }
 563
 564 // static
 565 void ParamTraits<ppapi::PPB_X509Certificate_Fields>::Log(const param_type& p,
 566                                                          std::string* l) {
 567 }
 568
 569 // ppapi::SocketOptionData -----------------------------------------------------
 570
 571 // static
 572 void ParamTraits<ppapi::SocketOptionData>::Write(Message* m,
 573                                                  const param_type& p) {
 574   ppapi::SocketOptionData::Type type = p.GetType();
 575   ParamTraits<int32_t>::Write(m, static_cast<int32_t>(type));
 576   switch (type) {
 577     case ppapi::SocketOptionData::TYPE_INVALID: {
 578       break;
 579     }
 580     case ppapi::SocketOptionData::TYPE_BOOL: {
 581       bool out_value = false;
 582       bool result = p.GetBool(&out_value);
 583       // Suppress unused variable warnings.
 584       static_cast<void>(result);
 585       DCHECK(result);
 586
 587       ParamTraits<bool>::Write(m, out_value);
 588       break;
 589     }
 590     case ppapi::SocketOptionData::TYPE_INT32: {
 591       int32_t out_value = 0;
 592       bool result = p.GetInt32(&out_value);
 593       // Suppress unused variable warnings.
 594       static_cast<void>(result);
 595       DCHECK(result);
 596
 597       ParamTraits<int32_t>::Write(m, out_value);
 598       break;
 599     }
 600     // No default so the compiler will warn on new types.
 601   }
 602 }
 603
 604 // static
 605 bool ParamTraits<ppapi::SocketOptionData>::Read(const Message* m,
 606                                                 PickleIterator* iter,
 607                                                 param_type* r) {
 608   *r = ppapi::SocketOptionData();
 609   int32_t type = 0;
 610   if (!ParamTraits<int32_t>::Read(m, iter, &type))
 611     return false;
 612   if (type != ppapi::SocketOptionData::TYPE_INVALID &&
 613       type != ppapi::SocketOptionData::TYPE_BOOL &&
 614       type != ppapi::SocketOptionData::TYPE_INT32) {
 615     return false;
 616   }
 617   switch (static_cast<ppapi::SocketOptionData::Type>(type)) {
 618     case ppapi::SocketOptionData::TYPE_INVALID: {
 619       return true;
 620     }
 621     case ppapi::SocketOptionData::TYPE_BOOL: {
 622       bool value = false;
 623       if (!ParamTraits<bool>::Read(m, iter, &value))
 624         return false;
 625       r->SetBool(value);
 626       return true;
 627     }
 628     case ppapi::SocketOptionData::TYPE_INT32: {
 629       int32_t value = 0;
 630       if (!ParamTraits<int32_t>::Read(m, iter, &value))
 631         return false;
 632       r->SetInt32(value);
 633       return true;
 634     }
 635     // No default so the compiler will warn on new types.
 636   }
 637   return false;
 638 }
 639
 640 // static
 641 void ParamTraits<ppapi::SocketOptionData>::Log(const param_type& p,
 642                                                std::string* l) {
 643 }
 644
 645 }  // namespace IPC