Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/pepper/v8_var_converter.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 "content/renderer/pepper/v8_var_converter.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <stack>
 #include <string>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/host_array_buffer_var.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/resource_converter.h"
 #include "content/renderer/pepper/v8object_var.h"
 #include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/dictionary_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "third_party/WebKit/public/web/WebArrayBuffer.h"
@@ skipping 204 matching lines @@
     *result = StringVar::StringToPPVar(std::string(*utf8, utf8.length()));
   } else if (val->IsObject()) {
     // For any other v8 objects, the conversion happens as follows:
     // 1) If the object is an array buffer, return an ArrayBufferVar.
     // 2) If object vars are allowed, return the object wrapped as a
     //    V8ObjectVar. This is to maintain backward compatibility with
     //    synchronous scripting in Flash.
     // 3) If the object is an array, return an ArrayVar.
     // 4) If the object can be converted to a resource, return the ResourceVar.
     // 5) Otherwise return a DictionaryVar.
-    scoped_ptr<blink::WebArrayBuffer> web_array_buffer(
+    std::unique_ptr<blink::WebArrayBuffer> web_array_buffer(
         blink::WebArrayBufferConverter::createFromV8Value(val, isolate));
     if (web_array_buffer.get()) {
       scoped_refptr<HostArrayBufferVar> buffer_var(
           new HostArrayBufferVar(*web_array_buffer));
       *result = buffer_var->GetPPVar();
     } else if (object_vars_allowed == V8VarConverter::kAllowObjectVars) {
       v8::Local<v8::Object> object = val.As<v8::Object>();
       *result = content::HostGlobals::Get()->
           host_var_tracker()->V8ObjectVarForV8Object(instance, object);
     } else if (val->IsArray()) {
@@ skipping 29 matching lines @@
 
 }  // namespace
 
 V8VarConverter::V8VarConverter(PP_Instance instance,
                                AllowObjectVars object_vars_allowed)
     : instance_(instance),
       object_vars_allowed_(object_vars_allowed) {
   resource_converter_.reset(new ResourceConverterImpl(instance));
 }
 
-V8VarConverter::V8VarConverter(PP_Instance instance,
-                               scoped_ptr<ResourceConverter> resource_converter)
+V8VarConverter::V8VarConverter(
+    PP_Instance instance,
+    std::unique_ptr<ResourceConverter> resource_converter)
     : instance_(instance),
       object_vars_allowed_(kDisallowObjectVars),
       resource_converter_(resource_converter.release()) {}
 
 V8VarConverter::~V8VarConverter() {}
 
 // To/FromV8Value use a stack-based DFS search to traverse V8/Var graph. Each
 // iteration, the top node on the stack examined. If the node has not been
 // visited yet (i.e. sentinel == false) then it is added to the list of parents
 // which contains all of the nodes on the path from the start node to the
@@ skipping 295 matching lines @@
             std::string(*name_utf8, name_utf8.length()), child_var);
         DCHECK(success);
       }
     }
   }
   *result_var = root;
   return true;
 }
 
 }  // namespace content