Convert //ppapi to use std::unique_ptr

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/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "ipc/ipc_message.h"
 #include "ppapi/proxy/ppapi_param_traits.h"
 #include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/dictionary_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/resource_var.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
@@ skipping 17 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,
-                             std::vector<scoped_ptr<RawVarData>>* data) {
+                             std::vector<std::unique_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(make_scoped_ptr(RawVarData::Create(var.type)));
+      data->push_back(base::WrapUnique(RawVarData::Create(var.type)));
       (*visited_map)[var.value.as_id] = data->size() - 1;
     }
   } else {
-    data->push_back(make_scoped_ptr(RawVarData::Create(var.type)));
+    data->push_back(base::WrapUnique(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
 
 // RawVarDataGraph ------------------------------------------------------------
 RawVarDataGraph::RawVarDataGraph() {
 }
 
 RawVarDataGraph::~RawVarDataGraph() {
 }
 
 // This function uses a stack-based DFS search to traverse the var graph. Each
 // iteration, the top node on the stack examined. If the node has not been
 // visited yet (i.e. !initialized()) then it is added to the list of
 // |parent_ids| which contains all of the nodes on the path from the start node
 // to the current node. Each of that nodes children are examined. If they appear
 // in the list of |parent_ids| it means we have a cycle and we return NULL.
 // Otherwise, if they haven't been visited yet we add them to the stack, If the
 // node at the top of the stack has already been visited, then we pop it off the
 // stack and erase it from |parent_ids|.
 // static
-scoped_ptr<RawVarDataGraph> RawVarDataGraph::Create(const PP_Var& var,
-                                                    PP_Instance instance) {
-  scoped_ptr<RawVarDataGraph> graph(new RawVarDataGraph);
+std::unique_ptr<RawVarDataGraph> RawVarDataGraph::Create(const PP_Var& var,
+                                                         PP_Instance instance) {
+  std::unique_ptr<RawVarDataGraph> graph(new RawVarDataGraph);
   // 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].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);
     if (!current_var_data->Init(current_var, instance)) {
       NOTREACHED();
-      return scoped_ptr<RawVarDataGraph>();
+      return std::unique_ptr<RawVarDataGraph>();

[piman, 2016/04/06 21:25:03]

nit: nullptr, here and below?

[dcheng, 2016/04/06 21:29:05]

Done.

     }
 
     // Add child nodes to the stack.
     if (current_var.type == PP_VARTYPE_ARRAY) {
       ArrayVar* array_var = ArrayVar::FromPPVar(current_var);
       if (!array_var) {
         NOTREACHED();
-        return scoped_ptr<RawVarDataGraph>();
+        return std::unique_ptr<RawVarDataGraph>();
       }
       for (ArrayVar::ElementVector::const_iterator iter =
                array_var->elements().begin();
            iter != array_var->elements().end();
            ++iter) {
         const PP_Var& child = iter->get();
         // If a child of this node is already in parent_ids, we have a cycle so
         // we just return null.
         if (CanHaveChildren(child) && parent_ids.count(child.value.as_id) != 0)
-          return scoped_ptr<RawVarDataGraph>();
+          return std::unique_ptr<RawVarDataGraph>();
         size_t child_id = GetOrCreateRawVarData(child, &visited_map,
                                                 &graph->data_);
         static_cast<ArrayRawVarData*>(current_var_data)->AddChild(child_id);
         if (!graph->data_[child_id]->initialized())
           stack.push(StackEntry(child, child_id));
       }
     } else if (current_var.type == PP_VARTYPE_DICTIONARY) {
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(current_var);
       if (!dict_var) {
         NOTREACHED();
-        return scoped_ptr<RawVarDataGraph>();
+        return std::unique_ptr<RawVarDataGraph>();
       }
       for (DictionaryVar::KeyValueMap::const_iterator iter =
                dict_var->key_value_map().begin();
            iter != dict_var->key_value_map().end();
            ++iter) {
         const PP_Var& child = iter->second.get();
         if (CanHaveChildren(child) && parent_ids.count(child.value.as_id) != 0)
-          return scoped_ptr<RawVarDataGraph>();
+          return std::unique_ptr<RawVarDataGraph>();
         size_t child_id = GetOrCreateRawVarData(child, &visited_map,
                                                 &graph->data_);
         static_cast<DictionaryRawVarData*>(
             current_var_data)->AddChild(iter->first, child_id);
         if (!graph->data_[child_id]->initialized())
           stack.push(StackEntry(child, child_id));
       }
     }
   }
   return graph;
@@ skipping 17 matching lines @@
                             const HandleWriter& handle_writer) {
   // Write the size, followed by each node in the graph.
   m->WriteUInt32(static_cast<uint32_t>(data_.size()));
   for (size_t i = 0; i < data_.size(); ++i) {
     m->WriteInt(data_[i]->Type());
     data_[i]->Write(m, handle_writer);
   }
 }
 
 // static
-scoped_ptr<RawVarDataGraph> RawVarDataGraph::Read(const base::Pickle* m,
-                                                  base::PickleIterator* iter) {
-  scoped_ptr<RawVarDataGraph> result(new RawVarDataGraph);
+std::unique_ptr<RawVarDataGraph> RawVarDataGraph::Read(
+    const base::Pickle* m,
+    base::PickleIterator* iter) {
+  std::unique_ptr<RawVarDataGraph> result(new RawVarDataGraph);
   uint32_t size = 0;
   if (!iter->ReadUInt32(&size))
-    return scoped_ptr<RawVarDataGraph>();
+    return std::unique_ptr<RawVarDataGraph>();

[piman, 2016/04/06 21:25:03]

(also here and below)

[dcheng, 2016/04/06 21:29:05]

FWIW, I'm cautiously optimistic that clang-tidy will help out with this in the
future, so I'm not too worried about fixing all of these.

   for (uint32_t i = 0; i < size; ++i) {
     int32_t type;
     if (!iter->ReadInt(&type))
-      return scoped_ptr<RawVarDataGraph>();
+      return std::unique_ptr<RawVarDataGraph>();
     PP_VarType var_type = static_cast<PP_VarType>(type);
-    result->data_.push_back(make_scoped_ptr(RawVarData::Create(var_type)));
+    result->data_.push_back(base::WrapUnique(RawVarData::Create(var_type)));
     if (!result->data_.back()->Read(var_type, m, iter))
-      return scoped_ptr<RawVarDataGraph>();
+      return std::unique_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();
     if (handle)
       result.push_back(handle);
@@ skipping 527 matching lines @@
     if (!IPC::ReadParam(m, iter, creation_message_.get()))
       return false;
   } else {
     creation_message_.reset();
   }
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi