Convert //ppapi to use std::unique_ptr

ppapi/proxy/raw_var_data.h

 // 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.
 
 #ifndef PPAPI_PROXY_RAW_VAR_DATA_H_
 #define PPAPI_PROXY_RAW_VAR_DATA_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/proxy/ppapi_param_traits.h"
 #include "ppapi/proxy/ppapi_proxy_export.h"
 #include "ppapi/proxy/serialized_handle.h"
 
 namespace base {
 class Pickle;
 class PickleIterator;
 }
@@ skipping 23 matching lines @@
 //     2  | var type |
 //        | var data |
 //        |   ....   |
 //
 // Vars that reference other vars (such as Arrays or Dictionaries) use indices
 // into the message to denote which PP_Var is pointed to.
 class PPAPI_PROXY_EXPORT RawVarDataGraph {
  public:
   // Construct a RawVarDataGraph from a given root PP_Var. A null pointer
   // is returned upon failure.
-  static scoped_ptr<RawVarDataGraph> Create(const PP_Var& var,
-                                            PP_Instance instance);
+  static std::unique_ptr<RawVarDataGraph> Create(const PP_Var& var,
+                                                 PP_Instance instance);
 
   // Constructs an empty RawVarDataGraph.
   RawVarDataGraph();
   ~RawVarDataGraph();
 
   // Construct a new PP_Var from the graph. All of the PP_Vars referenced by
   // the returned PP_Var are also constructed. Each PP_Var created has a
   // ref-count equal to the number of references it has in the graph of vars.
   // The returned var (the "root") has one additional reference.
   PP_Var CreatePPVar(PP_Instance instance);
 
   // Write the graph to a message using the given HandleWriter.
   void Write(base::Pickle* m, const HandleWriter& handle_writer);
 
   // Create a RawVarDataGraph from the given message.
-  static scoped_ptr<RawVarDataGraph> Read(const base::Pickle* m,
-                                          base::PickleIterator* iter);
+  static std::unique_ptr<RawVarDataGraph> Read(const base::Pickle* m,
+                                               base::PickleIterator* iter);
 
   // Returns a vector of SerializedHandles associated with this RawVarDataGraph.
   // Ownership of the pointers remains with the elements of the RawVarDataGraph.
   std::vector<SerializedHandle*> GetHandles();
 
   // Sets the threshold size at which point we switch from transmitting
   // array buffers in IPC messages to using shared memory. This is only used
   // for testing purposes where we need to transmit small buffers using shmem
   // (in order to have fast tests).
   static void SetMinimumArrayBufferSizeForShmemForTest(uint32_t threshold);
 
  private:
   // A list of the nodes in the graph.
-  std::vector<scoped_ptr<RawVarData>> data_;
+  std::vector<std::unique_ptr<RawVarData>> data_;
 
   DISALLOW_COPY_AND_ASSIGN(RawVarDataGraph);
 };
 
 // Abstract base class for the data contained in a PP_Var.
 class RawVarData {
  public:
   // Create a new, empty RawVarData for the given type.
   static RawVarData* Create(PP_VarType type);
   RawVarData();
@@ skipping 186 matching lines @@
   // Pending resource host ID in the renderer.
   int pending_renderer_host_id_;
 
   // Pending resource host ID in the browser.
   int pending_browser_host_id_;
 
   // A message containing information about how to create a plugin-side
   // resource. The message type will vary based on the resource type, and will
   // usually contain a pending resource host ID, and other required information.
   // If the resource was created directly, this is NULL.
-  scoped_ptr<IPC::Message> creation_message_;
+  std::unique_ptr<IPC::Message> creation_message_;
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_RAW_VAR_DATA_H_