Update ppapi to not use linked_ptr or ScopedVector

ppapi/proxy/raw_var_data.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/proxy/raw_var_data.h"
 
 #include <stack>
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
@@ skipping 26 matching lines @@
   PP_Var var;
   size_t data_index;
 };
 
 // For a given PP_Var, returns the RawVarData associated with it, or creates a
 // new one if there is no existing one. The data is appended to |data| if it
 // is newly created. The index into |data| pointing to the result is returned.
 // |visited_map| keeps track of RawVarDatas that have already been created.
 size_t GetOrCreateRawVarData(const PP_Var& var,
                              base::hash_map<int64_t, size_t>* visited_map,
-                             ScopedVector<RawVarData>* data) {
+                             std::vector<scoped_ptr<RawVarData>>* data) {
   if (VarTracker::IsVarTypeRefcounted(var.type)) {
     base::hash_map<int64_t, size_t>::iterator it = visited_map->find(
         var.value.as_id);
     if (it != visited_map->end()) {
       return it->second;
     } else {
-      data->push_back(RawVarData::Create(var.type));
+      data->push_back(make_scoped_ptr(RawVarData::Create(var.type)));
       (*visited_map)[var.value.as_id] = data->size() - 1;
     }
   } else {
-    data->push_back(RawVarData::Create(var.type));
+    data->push_back(make_scoped_ptr(RawVarData::Create(var.type)));
   }
   return data->size() - 1;
 }
 
 bool CanHaveChildren(PP_Var var) {
   return var.type == PP_VARTYPE_ARRAY || var.type == PP_VARTYPE_DICTIONARY;
 }
 
 }  // namespace
 
@@ skipping 20 matching lines @@
   // Map of |var.value.as_id| to a RawVarData index in RawVarDataGraph.
   base::hash_map<int64_t, size_t> visited_map;
   base::hash_set<int64_t> parent_ids;
 
   std::stack<StackEntry> stack;
   stack.push(StackEntry(var, GetOrCreateRawVarData(var, &visited_map,
                                                    &graph->data_)));
 
   while (!stack.empty()) {
     PP_Var current_var = stack.top().var;
-    RawVarData* current_var_data = graph->data_[stack.top().data_index];
+    RawVarData* current_var_data = graph->data_[stack.top().data_index].get();
 
     if (current_var_data->initialized()) {
       stack.pop();
       if (CanHaveChildren(current_var))
         parent_ids.erase(current_var.value.as_id);
       continue;
     }
 
     if (CanHaveChildren(current_var))
       parent_ids.insert(current_var.value.as_id);
@@ skipping 78 matching lines @@
                                                   base::PickleIterator* iter) {
   scoped_ptr<RawVarDataGraph> result(new RawVarDataGraph);
   uint32_t size = 0;
   if (!iter->ReadUInt32(&size))
     return scoped_ptr<RawVarDataGraph>();
   for (uint32_t i = 0; i < size; ++i) {
     int32_t type;
     if (!iter->ReadInt(&type))
       return scoped_ptr<RawVarDataGraph>();
     PP_VarType var_type = static_cast<PP_VarType>(type);
-    result->data_.push_back(RawVarData::Create(var_type));
+    result->data_.push_back(make_scoped_ptr(RawVarData::Create(var_type)));
     if (!result->data_.back()->Read(var_type, m, iter))
       return scoped_ptr<RawVarDataGraph>();
   }
   return result;
 }
 
 std::vector<SerializedHandle*> RawVarDataGraph::GetHandles() {
   std::vector<SerializedHandle*> result;
   for (size_t i = 0; i < data_.size(); ++i) {
     SerializedHandle* handle = data_[i]->GetHandle();
@@ skipping 532 matching lines @@
     if (!IPC::ReadParam(m, iter, creation_message_.get()))
       return false;
   } else {
     creation_message_.reset();
   }
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi