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

content/renderer/pepper/v8_var_converter_unittest.cc

 // Copyright (c) 2012 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 <cmath>
+#include <memory>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/values.h"
 #include "content/renderer/pepper/resource_converter.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/dictionary_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
@@ skipping 139 matching lines @@
   VarHandleMap var_handle_map;
   return Equals(var, val, &var_handle_map);
 }
 
 class V8VarConverterTest : public testing::Test {
  public:
   V8VarConverterTest()
       : isolate_(v8::Isolate::GetCurrent()) {
     PP_Instance dummy = 1234;
     converter_.reset(new V8VarConverter(
-        dummy, scoped_ptr<ResourceConverter>(new MockResourceConverter)));
+        dummy, std::unique_ptr<ResourceConverter>(new MockResourceConverter)));
   }
   ~V8VarConverterTest() override {}
 
   // testing::Test implementation.
   void SetUp() override {
     ProxyLock::Acquire();
     v8::HandleScope handle_scope(isolate_);
     v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate_);
     context_.Reset(isolate_, v8::Context::New(isolate_, NULL, global));
   }
@@ skipping 41 matching lines @@
       return false;
     ScopedPPVar actual(ScopedPPVar::PassRef(), actual_var);
     return TestEqual(expected.get(), actual.get(), false);
   }
 
   v8::Isolate* isolate_;
 
   // Context for the JavaScript in the test.
   v8::Persistent<v8::Context> context_;
 
-  scoped_ptr<V8VarConverter> converter_;
+  std::unique_ptr<V8VarConverter> converter_;
 
  private:
   base::MessageLoop message_loop_;  // Required to receive callbacks.
 
   TestGlobals globals_;
 };
 
 }  // namespace
 
 TEST_F(V8VarConverterTest, SimpleRoundTripTest) {
@@ skipping 194 matching lines @@
     expected->SetWithStringKey("null", quux.get());
     ScopedPPVar oops(ScopedPPVar::PassRef(), StringVar::StringToPPVar("oops"));
     expected->SetWithStringKey("undefined", oops.get());
     ScopedPPVar release_expected(ScopedPPVar::PassRef(), expected->GetPPVar());
 
     ASSERT_TRUE(TestEqual(release_expected.get(), release_actual.get(), true));
   }
 }
 
 }  // namespace content