ppapi/proxy/raw_var_data.cc

   1 // Copyright (c) 2013 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/raw_var_data.h"
   6
   7 #include <stack>
   8
   9 #include "base/containers/hash_tables.h"
  10 #include "base/stl_util.h"
  11 #include "ipc/ipc_message.h"
  12 #include "ppapi/proxy/ppapi_param_traits.h"
  13 #include "ppapi/shared_impl/array_var.h"
  14 #include "ppapi/shared_impl/dictionary_var.h"
  15 #include "ppapi/shared_impl/ppapi_globals.h"
  16 #include "ppapi/shared_impl/resource_var.h"
  17 #include "ppapi/shared_impl/scoped_pp_var.h"
  18 #include "ppapi/shared_impl/var.h"
  19 #include "ppapi/shared_impl/var_tracker.h"
  20
  21 using std::make_pair;
  22
  23 namespace ppapi {
  24 namespace proxy {
  25
  26 namespace {
  27
  28 // When sending array buffers, if the size is over 256K, we use shared
  29 // memory instead of sending the data over IPC. Light testing suggests
  30 // shared memory is much faster for 256K and larger messages.
  31 static const uint32 kMinimumArrayBufferSizeForShmem = 256 * 1024;
  32 static uint32 g_minimum_array_buffer_size_for_shmem =
  33     kMinimumArrayBufferSizeForShmem;
  34
  35 struct StackEntry {
  36   StackEntry(PP_Var v, size_t i) : var(v), data_index(i) {}
  37   PP_Var var;
  38   size_t data_index;
  39 };
  40
  41 // For a given PP_Var, returns the RawVarData associated with it, or creates a
  42 // new one if there is no existing one. The data is appended to |data| if it
  43 // is newly created. The index into |data| pointing to the result is returned.
  44 // |visited_map| keeps track of RawVarDatas that have already been created.
  45 size_t GetOrCreateRawVarData(const PP_Var& var,
  46                              base::hash_map<int64_t, size_t>* visited_map,
  47                              ScopedVector<RawVarData>* data) {
  48   if (VarTracker::IsVarTypeRefcounted(var.type)) {
  49     base::hash_map<int64_t, size_t>::iterator it = visited_map->find(
  50         var.value.as_id);
  51     if (it != visited_map->end()) {
  52       return it->second;
  53     } else {
  54       data->push_back(RawVarData::Create(var.type));
  55       (*visited_map)[var.value.as_id] = data->size() - 1;
  56     }
  57   } else {
  58     data->push_back(RawVarData::Create(var.type));
  59   }
  60   return data->size() - 1;
  61 }
  62
  63 bool CanHaveChildren(PP_Var var) {
  64   return var.type == PP_VARTYPE_ARRAY || var.type == PP_VARTYPE_DICTIONARY;
  65 }
  66
  67 }  // namespace
  68
  69 // RawVarDataGraph ------------------------------------------------------------
  70 RawVarDataGraph::RawVarDataGraph() {
  71 }
  72
  73 RawVarDataGraph::~RawVarDataGraph() {
  74 }
  75
  76 // This function uses a stack-based DFS search to traverse the var graph. Each
  77 // iteration, the top node on the stack examined. If the node has not been
  78 // visited yet (i.e. !initialized()) then it is added to the list of
  79 // |parent_ids| which contains all of the nodes on the path from the start node
  80 // to the current node. Each of that nodes children are examined. If they appear
  81 // in the list of |parent_ids| it means we have a cycle and we return NULL.
  82 // Otherwise, if they haven't been visited yet we add them to the stack, If the
  83 // node at the top of the stack has already been visited, then we pop it off the
  84 // stack and erase it from |parent_ids|.
  85 // static
  86 scoped_ptr<RawVarDataGraph> RawVarDataGraph::Create(const PP_Var& var,
  87                                                     PP_Instance instance) {
  88   scoped_ptr<RawVarDataGraph> graph(new RawVarDataGraph);
  89   // Map of |var.value.as_id| to a RawVarData index in RawVarDataGraph.
  90   base::hash_map<int64_t, size_t> visited_map;
  91   base::hash_set<int64_t> parent_ids;
  92
  93   std::stack<StackEntry> stack;
  94   stack.push(StackEntry(var, GetOrCreateRawVarData(var, &visited_map,
  95                                                    &graph->data_)));
  96
  97   while (!stack.empty()) {
  98     PP_Var current_var = stack.top().var;
  99     RawVarData* current_var_data = graph->data_[stack.top().data_index];
 100
 101     if (current_var_data->initialized()) {
 102       stack.pop();
 103       if (CanHaveChildren(current_var))
 104         parent_ids.erase(current_var.value.as_id);
 105       continue;
 106     }
 107
 108     if (CanHaveChildren(current_var))
 109       parent_ids.insert(current_var.value.as_id);
 110     if (!current_var_data->Init(current_var, instance)) {
 111       NOTREACHED();
 112       return scoped_ptr<RawVarDataGraph>();
 113     }
 114
 115     // Add child nodes to the stack.
 116     if (current_var.type == PP_VARTYPE_ARRAY) {
 117       ArrayVar* array_var = ArrayVar::FromPPVar(current_var);
 118       if (!array_var) {
 119         NOTREACHED();
 120         return scoped_ptr<RawVarDataGraph>();
 121       }
 122       for (ArrayVar::ElementVector::const_iterator iter =
 123                array_var->elements().begin();
 124            iter != array_var->elements().end();
 125            ++iter) {
 126         const PP_Var& child = iter->get();
 127         // If a child of this node is already in parent_ids, we have a cycle so
 128         // we just return null.
 129         if (CanHaveChildren(child) && parent_ids.count(child.value.as_id) != 0)
 130           return scoped_ptr<RawVarDataGraph>();
 131         size_t child_id = GetOrCreateRawVarData(child, &visited_map,
 132                                                 &graph->data_);
 133         static_cast<ArrayRawVarData*>(current_var_data)->AddChild(child_id);
 134         if (!graph->data_[child_id]->initialized())
 135           stack.push(StackEntry(child, child_id));
 136       }
 137     } else if (current_var.type == PP_VARTYPE_DICTIONARY) {
 138       DictionaryVar* dict_var = DictionaryVar::FromPPVar(current_var);
 139       if (!dict_var) {
 140         NOTREACHED();
 141         return scoped_ptr<RawVarDataGraph>();
 142       }
 143       for (DictionaryVar::KeyValueMap::const_iterator iter =
 144                dict_var->key_value_map().begin();
 145            iter != dict_var->key_value_map().end();
 146            ++iter) {
 147         const PP_Var& child = iter->second.get();
 148         if (CanHaveChildren(child) && parent_ids.count(child.value.as_id) != 0)
 149           return scoped_ptr<RawVarDataGraph>();
 150         size_t child_id = GetOrCreateRawVarData(child, &visited_map,
 151                                                 &graph->data_);
 152         static_cast<DictionaryRawVarData*>(
 153             current_var_data)->AddChild(iter->first, child_id);
 154         if (!graph->data_[child_id]->initialized())
 155           stack.push(StackEntry(child, child_id));
 156       }
 157     }
 158   }
 159   return graph.Pass();
 160 }
 161
 162 PP_Var RawVarDataGraph::CreatePPVar(PP_Instance instance) {
 163   // Create and initialize each node in the graph.
 164   std::vector<PP_Var> graph;
 165   for (size_t i = 0; i < data_.size(); ++i)
 166     graph.push_back(data_[i]->CreatePPVar(instance));
 167   for (size_t i = 0; i < data_.size(); ++i)
 168     data_[i]->PopulatePPVar(graph[i], graph);
 169   // Everything except the root will have one extra ref. Remove that ref.
 170   for (size_t i = 1; i < data_.size(); ++i)
 171     ScopedPPVar(ScopedPPVar::PassRef(), graph[i]);
 172   // The first element is the root.
 173   return graph[0];
 174 }
 175
 176 void RawVarDataGraph::Write(IPC::Message* m,
 177                             const HandleWriter& handle_writer) {
 178   // Write the size, followed by each node in the graph.
 179   m->WriteUInt32(static_cast<uint32_t>(data_.size()));
 180   for (size_t i = 0; i < data_.size(); ++i) {
 181     m->WriteInt(data_[i]->Type());
 182     data_[i]->Write(m, handle_writer);
 183   }
 184 }
 185
 186 // static
 187 scoped_ptr<RawVarDataGraph> RawVarDataGraph::Read(const IPC::Message* m,
 188                                                   PickleIterator* iter) {
 189   scoped_ptr<RawVarDataGraph> result(new RawVarDataGraph);
 190   uint32_t size = 0;
 191   if (!m->ReadUInt32(iter, &size))
 192     return scoped_ptr<RawVarDataGraph>();
 193   for (uint32_t i = 0; i < size; ++i) {
 194     int32_t type;
 195     if (!m->ReadInt(iter, &type))
 196       return scoped_ptr<RawVarDataGraph>();
 197     PP_VarType var_type = static_cast<PP_VarType>(type);
 198     result->data_.push_back(RawVarData::Create(var_type));
 199     if (!result->data_.back()->Read(var_type, m, iter))
 200       return scoped_ptr<RawVarDataGraph>();
 201   }
 202   return result.Pass();
 203 }
 204
 205 std::vector<SerializedHandle*> RawVarDataGraph::GetHandles() {
 206   std::vector<SerializedHandle*> result;
 207   for (size_t i = 0; i < data_.size(); ++i) {
 208     SerializedHandle* handle = data_[i]->GetHandle();
 209     if (handle)
 210       result.push_back(handle);
 211   }
 212   return result;
 213 }
 214
 215 // static
 216 void RawVarDataGraph::SetMinimumArrayBufferSizeForShmemForTest(
 217     uint32 threshold) {
 218   if (threshold == 0)
 219     g_minimum_array_buffer_size_for_shmem = kMinimumArrayBufferSizeForShmem;
 220   else
 221     g_minimum_array_buffer_size_for_shmem = threshold;
 222 }
 223
 224 // RawVarData ------------------------------------------------------------------
 225
 226 // static
 227 RawVarData* RawVarData::Create(PP_VarType type) {
 228   switch (type) {
 229     case PP_VARTYPE_UNDEFINED:
 230     case PP_VARTYPE_NULL:
 231     case PP_VARTYPE_BOOL:
 232     case PP_VARTYPE_INT32:
 233     case PP_VARTYPE_DOUBLE:
 234     case PP_VARTYPE_OBJECT:
 235       return new BasicRawVarData();
 236     case PP_VARTYPE_STRING:
 237       return new StringRawVarData();
 238     case PP_VARTYPE_ARRAY_BUFFER:
 239       return new ArrayBufferRawVarData();
 240     case PP_VARTYPE_ARRAY:
 241       return new ArrayRawVarData();
 242     case PP_VARTYPE_DICTIONARY:
 243       return new DictionaryRawVarData();
 244     case PP_VARTYPE_RESOURCE:
 245       return new ResourceRawVarData();
 246   }
 247   NOTREACHED();
 248   return NULL;
 249 }
 250
 251 RawVarData::RawVarData() : initialized_(false) {
 252 }
 253
 254 RawVarData::~RawVarData() {
 255 }
 256
 257 SerializedHandle* RawVarData::GetHandle() {
 258   return NULL;
 259 }
 260
 261 // BasicRawVarData -------------------------------------------------------------
 262 BasicRawVarData::BasicRawVarData() {
 263 }
 264
 265 BasicRawVarData::~BasicRawVarData() {
 266 }
 267
 268 PP_VarType BasicRawVarData::Type() {
 269   return var_.type;
 270 }
 271
 272 bool BasicRawVarData::Init(const PP_Var& var, PP_Instance /*instance*/) {
 273   var_ = var;
 274   initialized_ = true;
 275   return true;
 276 }
 277
 278 PP_Var BasicRawVarData::CreatePPVar(PP_Instance instance) {
 279   return var_;
 280 }
 281
 282 void BasicRawVarData::PopulatePPVar(const PP_Var& var,
 283                                     const std::vector<PP_Var>& graph) {
 284 }
 285
 286 void BasicRawVarData::Write(
 287     IPC::Message* m,
 288     const HandleWriter& handle_writer) {
 289   switch (var_.type) {
 290     case PP_VARTYPE_UNDEFINED:
 291     case PP_VARTYPE_NULL:
 292       // These don't need any data associated with them other than the type we
 293       // just serialized.
 294       break;
 295     case PP_VARTYPE_BOOL:
 296       m->WriteBool(PP_ToBool(var_.value.as_bool));
 297       break;
 298     case PP_VARTYPE_INT32:
 299       m->WriteInt(var_.value.as_int);
 300       break;
 301     case PP_VARTYPE_DOUBLE:
 302       IPC::ParamTraits<double>::Write(m, var_.value.as_double);
 303       break;
 304     case PP_VARTYPE_OBJECT:
 305       m->WriteInt64(var_.value.as_id);
 306       break;
 307     default:
 308       NOTREACHED();
 309       break;
 310   }
 311 }
 312
 313 bool BasicRawVarData::Read(PP_VarType type,
 314                            const IPC::Message* m,
 315                            PickleIterator* iter) {
 316   PP_Var result;
 317   result.type = type;
 318   switch (type) {
 319     case PP_VARTYPE_UNDEFINED:
 320     case PP_VARTYPE_NULL:
 321       // These don't have any data associated with them other than the type we
 322       // just serialized.
 323       break;
 324     case PP_VARTYPE_BOOL: {
 325       bool bool_value;
 326       if (!m->ReadBool(iter, &bool_value))
 327         return false;
 328       result.value.as_bool = PP_FromBool(bool_value);
 329       break;
 330     }
 331     case PP_VARTYPE_INT32:
 332       if (!m->ReadInt(iter, &result.value.as_int))
 333         return false;
 334       break;
 335     case PP_VARTYPE_DOUBLE:
 336       if (!IPC::ParamTraits<double>::Read(m, iter, &result.value.as_double))
 337         return false;
 338       break;
 339     case PP_VARTYPE_OBJECT:
 340       if (!m->ReadInt64(iter, &result.value.as_id))
 341         return false;
 342       break;
 343     default:
 344       NOTREACHED();
 345       return false;
 346   }
 347   var_ = result;
 348   return true;
 349 }
 350
 351 // StringRawVarData ------------------------------------------------------------
 352 StringRawVarData::StringRawVarData() {
 353 }
 354
 355 StringRawVarData::~StringRawVarData() {
 356 }
 357
 358 PP_VarType StringRawVarData::Type() {
 359   return PP_VARTYPE_STRING;
 360 }
 361
 362 bool StringRawVarData::Init(const PP_Var& var, PP_Instance /*instance*/) {
 363   DCHECK(var.type == PP_VARTYPE_STRING);
 364   StringVar* string_var = StringVar::FromPPVar(var);
 365   if (!string_var)
 366     return false;
 367   data_ = string_var->value();
 368   initialized_ = true;
 369   return true;
 370 }
 371
 372 PP_Var StringRawVarData::CreatePPVar(PP_Instance instance) {
 373   return StringVar::SwapValidatedUTF8StringIntoPPVar(&data_);
 374 }
 375
 376 void StringRawVarData::PopulatePPVar(const PP_Var& var,
 377                                      const std::vector<PP_Var>& graph) {
 378 }
 379
 380 void StringRawVarData::Write(IPC::Message* m,
 381                              const HandleWriter& handle_writer) {
 382   m->WriteString(data_);
 383 }
 384
 385 bool StringRawVarData::Read(PP_VarType type,
 386                             const IPC::Message* m,
 387                             PickleIterator* iter) {
 388   if (!m->ReadString(iter, &data_))
 389     return false;
 390   return true;
 391 }
 392
 393 // ArrayBufferRawVarData -------------------------------------------------------
 394 ArrayBufferRawVarData::ArrayBufferRawVarData() {
 395 }
 396
 397 ArrayBufferRawVarData::~ArrayBufferRawVarData() {
 398 }
 399
 400 PP_VarType ArrayBufferRawVarData::Type() {
 401   return PP_VARTYPE_ARRAY_BUFFER;
 402 }
 403
 404 bool ArrayBufferRawVarData::Init(const PP_Var& var,
 405                                  PP_Instance instance) {
 406   DCHECK(var.type == PP_VARTYPE_ARRAY_BUFFER);
 407   ArrayBufferVar* buffer_var = ArrayBufferVar::FromPPVar(var);
 408   if (!buffer_var)
 409     return false;
 410   bool using_shmem = false;
 411   if (buffer_var->ByteLength() >= g_minimum_array_buffer_size_for_shmem &&
 412       instance != 0) {
 413     int host_handle_id;
 414     base::SharedMemoryHandle plugin_handle;
 415     using_shmem = buffer_var->CopyToNewShmem(instance,
 416                                              &host_handle_id,
 417                                              &plugin_handle);
 418     if (using_shmem) {
 419       if (host_handle_id != -1) {
 420         DCHECK(!base::SharedMemory::IsHandleValid(plugin_handle));
 421         DCHECK(PpapiGlobals::Get()->IsPluginGlobals());
 422         type_ = ARRAY_BUFFER_SHMEM_HOST;
 423         host_shm_handle_id_ = host_handle_id;
 424       } else {
 425         DCHECK(base::SharedMemory::IsHandleValid(plugin_handle));
 426         DCHECK(PpapiGlobals::Get()->IsHostGlobals());
 427         type_ = ARRAY_BUFFER_SHMEM_PLUGIN;
 428         plugin_shm_handle_ = SerializedHandle(plugin_handle,
 429                                               buffer_var->ByteLength());
 430       }
 431     }
 432   }
 433   if (!using_shmem) {
 434     type_ = ARRAY_BUFFER_NO_SHMEM;
 435     data_ = std::string(static_cast<const char*>(buffer_var->Map()),
 436                         buffer_var->ByteLength());
 437   }
 438   initialized_ = true;
 439   return true;
 440 }
 441
 442 PP_Var ArrayBufferRawVarData::CreatePPVar(PP_Instance instance) {
 443   PP_Var result = PP_MakeUndefined();
 444   switch (type_) {
 445     case ARRAY_BUFFER_SHMEM_HOST: {
 446       base::SharedMemoryHandle host_handle;
 447       uint32 size_in_bytes;
 448       bool ok = PpapiGlobals::Get()->GetVarTracker()->
 449           StopTrackingSharedMemoryHandle(host_shm_handle_id_,
 450                                          instance,
 451                                          &host_handle,
 452                                          &size_in_bytes);
 453       if (ok) {
 454         result = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
 455             size_in_bytes, host_handle);
 456       } else {
 457         LOG(ERROR) << "Couldn't find array buffer id: " << host_shm_handle_id_;
 458         return PP_MakeUndefined();
 459       }
 460       break;
 461     }
 462     case ARRAY_BUFFER_SHMEM_PLUGIN: {
 463       result = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
 464           plugin_shm_handle_.size(),
 465           plugin_shm_handle_.shmem());
 466       break;
 467     }
 468     case ARRAY_BUFFER_NO_SHMEM: {
 469       result = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
 470           static_cast<uint32>(data_.size()), data_.data());
 471       break;
 472     }
 473     default:
 474       NOTREACHED();
 475       return PP_MakeUndefined();
 476   }
 477   DCHECK(result.type == PP_VARTYPE_ARRAY_BUFFER);
 478   return result;
 479 }
 480
 481 void ArrayBufferRawVarData::PopulatePPVar(const PP_Var& var,
 482                                           const std::vector<PP_Var>& graph) {
 483 }
 484
 485 void ArrayBufferRawVarData::Write(
 486     IPC::Message* m,
 487     const HandleWriter& handle_writer) {
 488   m->WriteInt(type_);
 489   switch (type_) {
 490     case ARRAY_BUFFER_SHMEM_HOST:
 491       m->WriteInt(host_shm_handle_id_);
 492       break;
 493     case ARRAY_BUFFER_SHMEM_PLUGIN:
 494       handle_writer.Run(m, plugin_shm_handle_);
 495       break;
 496     case ARRAY_BUFFER_NO_SHMEM:
 497       m->WriteString(data_);
 498       break;
 499   }
 500 }
 501
 502 bool ArrayBufferRawVarData::Read(PP_VarType type,
 503                                  const IPC::Message* m,
 504                                  PickleIterator* iter) {
 505   int shmem_type;
 506   if (!m->ReadInt(iter, &shmem_type))
 507     return false;
 508   type_ = static_cast<ShmemType>(shmem_type);
 509   switch (type_) {
 510     case ARRAY_BUFFER_SHMEM_HOST:
 511       if (!m->ReadInt(iter, &host_shm_handle_id_))
 512         return false;
 513       break;
 514     case ARRAY_BUFFER_SHMEM_PLUGIN:
 515       if (!IPC::ParamTraits<SerializedHandle>::Read(
 516               m, iter, &plugin_shm_handle_)) {
 517         return false;
 518       }
 519       break;
 520     case ARRAY_BUFFER_NO_SHMEM:
 521       if (!m->ReadString(iter, &data_))
 522         return false;
 523       break;
 524     default:
 525       // We read an invalid ID.
 526       NOTREACHED();
 527       return false;
 528   }
 529   return true;
 530 }
 531
 532 SerializedHandle* ArrayBufferRawVarData::GetHandle() {
 533   if (type_ == ARRAY_BUFFER_SHMEM_PLUGIN && plugin_shm_handle_.size() != 0)
 534     return &plugin_shm_handle_;
 535   return NULL;
 536 }
 537
 538 // ArrayRawVarData -------------------------------------------------------------
 539 ArrayRawVarData::ArrayRawVarData() {
 540 }
 541
 542 ArrayRawVarData::~ArrayRawVarData() {
 543 }
 544
 545 void ArrayRawVarData::AddChild(size_t element) {
 546   children_.push_back(element);
 547 }
 548
 549 PP_VarType ArrayRawVarData::Type() {
 550   return PP_VARTYPE_ARRAY;
 551 }
 552
 553 bool ArrayRawVarData::Init(const PP_Var& var, PP_Instance /*instance*/) {
 554   initialized_ = true;
 555   DCHECK(var.type == PP_VARTYPE_ARRAY);
 556   initialized_ = true;
 557   return true;
 558 }
 559
 560 PP_Var ArrayRawVarData::CreatePPVar(PP_Instance instance) {
 561   return (new ArrayVar())->GetPPVar();
 562 }
 563
 564 void ArrayRawVarData::PopulatePPVar(const PP_Var& var,
 565                                     const std::vector<PP_Var>& graph) {
 566   if (var.type != PP_VARTYPE_ARRAY) {
 567     NOTREACHED();
 568     return;
 569   }
 570   ArrayVar* array_var = ArrayVar::FromPPVar(var);
 571   DCHECK(array_var->elements().empty());
 572   for (size_t i = 0; i < children_.size(); ++i)
 573     array_var->elements().push_back(ScopedPPVar(graph[children_[i]]));
 574 }
 575
 576 void ArrayRawVarData::Write(IPC::Message* m,
 577                             const HandleWriter& handle_writer) {
 578   m->WriteUInt32(static_cast<uint32_t>(children_.size()));
 579   for (size_t i = 0; i < children_.size(); ++i)
 580     m->WriteUInt32(static_cast<uint32_t>(children_[i]));
 581 }
 582
 583 bool ArrayRawVarData::Read(PP_VarType type,
 584                            const IPC::Message* m,
 585                            PickleIterator* iter) {
 586   uint32_t size;
 587   if (!m->ReadUInt32(iter, &size))
 588     return false;
 589   for (uint32_t i = 0; i < size; ++i) {
 590     uint32_t index;
 591     if (!m->ReadUInt32(iter, &index))
 592       return false;
 593     children_.push_back(index);
 594   }
 595   return true;
 596 }
 597
 598 // DictionaryRawVarData --------------------------------------------------------
 599 DictionaryRawVarData::DictionaryRawVarData() {
 600 }
 601
 602 DictionaryRawVarData::~DictionaryRawVarData() {
 603 }
 604
 605 void DictionaryRawVarData::AddChild(const std::string& key,
 606                                     size_t value) {
 607   children_.push_back(make_pair(key, value));
 608 }
 609
 610 PP_VarType DictionaryRawVarData::Type() {
 611   return PP_VARTYPE_DICTIONARY;
 612 }
 613
 614 bool DictionaryRawVarData::Init(const PP_Var& var, PP_Instance /*instance*/) {
 615   DCHECK(var.type == PP_VARTYPE_DICTIONARY);
 616   initialized_ = true;
 617   return true;
 618 }
 619
 620 PP_Var DictionaryRawVarData::CreatePPVar(PP_Instance instance) {
 621   return (new DictionaryVar())->GetPPVar();
 622 }
 623
 624 void DictionaryRawVarData::PopulatePPVar(const PP_Var& var,
 625                                          const std::vector<PP_Var>& graph) {
 626   if (var.type != PP_VARTYPE_DICTIONARY) {
 627     NOTREACHED();
 628     return;
 629   }
 630   DictionaryVar* dictionary_var = DictionaryVar::FromPPVar(var);
 631   DCHECK(dictionary_var->key_value_map().empty());
 632   for (size_t i = 0; i < children_.size(); ++i) {
 633     bool success = dictionary_var->SetWithStringKey(children_[i].first,
 634                                                     graph[children_[i].second]);
 635     DCHECK(success);
 636   }
 637 }
 638
 639 void DictionaryRawVarData::Write(
 640     IPC::Message* m,
 641     const HandleWriter& handle_writer) {
 642   m->WriteUInt32(static_cast<uint32_t>(children_.size()));
 643   for (size_t i = 0; i < children_.size(); ++i) {
 644     m->WriteString(children_[i].first);
 645     m->WriteUInt32(static_cast<uint32_t>(children_[i].second));
 646   }
 647 }
 648
 649 bool DictionaryRawVarData::Read(PP_VarType type,
 650                                 const IPC::Message* m,
 651                                 PickleIterator* iter) {
 652   uint32_t size;
 653   if (!m->ReadUInt32(iter, &size))
 654     return false;
 655   for (uint32_t i = 0; i < size; ++i) {
 656     std::string key;
 657     uint32_t value;
 658     if (!m->ReadString(iter, &key))
 659       return false;
 660     if (!m->ReadUInt32(iter, &value))
 661       return false;
 662     children_.push_back(make_pair(key, value));
 663   }
 664   return true;
 665 }
 666
 667 // ResourceRawVarData ----------------------------------------------------------
 668 ResourceRawVarData::ResourceRawVarData()
 669     : pp_resource_(0),
 670       pending_renderer_host_id_(0),
 671       pending_browser_host_id_(0) {}
 672
 673 ResourceRawVarData::~ResourceRawVarData() {
 674 }
 675
 676 PP_VarType ResourceRawVarData::Type() {
 677   return PP_VARTYPE_RESOURCE;
 678 }
 679
 680 bool ResourceRawVarData::Init(const PP_Var& var, PP_Instance /*instance*/) {
 681   DCHECK(var.type == PP_VARTYPE_RESOURCE);
 682   ResourceVar* resource_var = ResourceVar::FromPPVar(var);
 683   if (!resource_var)
 684     return false;
 685   pp_resource_ = resource_var->GetPPResource();
 686   const IPC::Message* message = resource_var->GetCreationMessage();
 687   if (message)
 688     creation_message_.reset(new IPC::Message(*message));
 689   else
 690     creation_message_.reset();
 691   pending_renderer_host_id_ = resource_var->GetPendingRendererHostId();
 692   pending_browser_host_id_ = resource_var->GetPendingBrowserHostId();
 693   initialized_ = true;
 694   return true;
 695 }
 696
 697 PP_Var ResourceRawVarData::CreatePPVar(PP_Instance instance) {
 698   // If this is not a pending resource host, just create the var.
 699   if (pp_resource_ || !creation_message_) {
 700     return PpapiGlobals::Get()->GetVarTracker()->MakeResourcePPVar(
 701         pp_resource_);
 702   }
 703
 704   // This is a pending resource host, so create the resource and var.
 705   return PpapiGlobals::Get()->GetVarTracker()->MakeResourcePPVarFromMessage(
 706       instance,
 707       *creation_message_,
 708       pending_renderer_host_id_,
 709       pending_browser_host_id_);
 710 }
 711
 712 void ResourceRawVarData::PopulatePPVar(const PP_Var& var,
 713                                        const std::vector<PP_Var>& graph) {
 714 }
 715
 716 void ResourceRawVarData::Write(IPC::Message* m,
 717                                const HandleWriter& handle_writer) {
 718   m->WriteInt(static_cast<int>(pp_resource_));
 719   m->WriteInt(pending_renderer_host_id_);
 720   m->WriteInt(pending_browser_host_id_);
 721   m->WriteBool(creation_message_);
 722   if (creation_message_)
 723     IPC::ParamTraits<IPC::Message>::Write(m, *creation_message_);
 724 }
 725
 726 bool ResourceRawVarData::Read(PP_VarType type,
 727                               const IPC::Message* m,
 728                               PickleIterator* iter) {
 729   int value;
 730   if (!m->ReadInt(iter, &value))
 731     return false;
 732   pp_resource_ = static_cast<PP_Resource>(value);
 733   if (!m->ReadInt(iter, &pending_renderer_host_id_))
 734     return false;
 735   if (!m->ReadInt(iter, &pending_browser_host_id_))
 736     return false;
 737   bool has_creation_message;
 738   if (!m->ReadBool(iter, &has_creation_message))
 739     return false;
 740   if (has_creation_message) {
 741     creation_message_.reset(new IPC::Message());
 742     if (!IPC::ParamTraits<IPC::Message>::Read(m, iter, creation_message_.get()))
 743       return false;
 744   } else {
 745     creation_message_.reset();
 746   }
 747   return true;
 748 }
 749
 750 }  // namespace proxy
 751 }  // namespace ppapi