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