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

extensions/renderer/module_system_unittest.cc

 // Copyright 2014 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 "extensions/renderer/module_system.h"
 
 #include <stdint.h>
 
+#include <memory>
 #include <utility>
 
-#include "base/memory/scoped_ptr.h"
 #include "extensions/renderer/module_system_test.h"
 #include "gin/modules/module_registry.h"
 
 namespace extensions {
 
 class CounterNatives : public ObjectBackedNativeHandler {
  public:
   explicit CounterNatives(ScriptContext* context)
       : ObjectBackedNativeHandler(context), counter_(0) {
     RouteFunction("Get",
@@ skipping 27 matching lines @@
   bool handled_exception() const { return handled_exception_; }
 
  private:
   bool handled_exception_;
 };
 
 TEST_F(ModuleSystemTest, TestExceptionHandling) {
   ModuleSystem::NativesEnabledScope natives_enabled_scope(
       env()->module_system());
   TestExceptionHandler* handler = new TestExceptionHandler;
-  scoped_ptr<ModuleSystem::ExceptionHandler> scoped_handler(handler);
+  std::unique_ptr<ModuleSystem::ExceptionHandler> scoped_handler(handler);
   ASSERT_FALSE(handler->handled_exception());
   env()->module_system()->SetExceptionHandlerForTest(std::move(scoped_handler));
 
   env()->RegisterModule("test", "throw 'hi';");
   env()->module_system()->Require("test");
   ASSERT_TRUE(handler->handled_exception());
 
   ExpectNoAssertionsMade();
 }
 
@@ skipping 111 matching lines @@
                         "assert.AssertTrue(object.thing.y() == 10);"
                         "assert.AssertTrue(object.thing.z == 1);");
   env()->module_system()->Require("test");
 }
 
 TEST_F(ModuleSystemTest, TestLazyFieldIsOnlyEvaledOnce) {
   ModuleSystem::NativesEnabledScope natives_enabled_scope(
       env()->module_system());
   env()->module_system()->RegisterNativeHandler(
       "counter",
-      scoped_ptr<NativeHandler>(new CounterNatives(env()->context())));
+      std::unique_ptr<NativeHandler>(new CounterNatives(env()->context())));
   env()->RegisterModule("lazy",
                         "requireNative('counter').Increment();"
                         "exports.$set('x', 5);");
 
   v8::Local<v8::Object> object = env()->CreateGlobal("object");
 
   env()->module_system()->SetLazyField(object, "x", "lazy", "x");
 
   env()->RegisterModule("test",
                         "var assert = requireNative('assert');"
@@ skipping 34 matching lines @@
                         "var assert = requireNative('assert');"
                         "assert.AssertTrue(object.thing.x == 5);");
   env()->module_system()->Require("test");
 }
 
 TEST_F(ModuleSystemTest, TestModulesOnlyGetEvaledOnce) {
   ModuleSystem::NativesEnabledScope natives_enabled_scope(
       env()->module_system());
   env()->module_system()->RegisterNativeHandler(
       "counter",
-      scoped_ptr<NativeHandler>(new CounterNatives(env()->context())));
+      std::unique_ptr<NativeHandler>(new CounterNatives(env()->context())));
 
   env()->RegisterModule("incrementsWhenEvaled",
                         "requireNative('counter').Increment();");
   env()->RegisterModule("test",
                         "var assert = requireNative('assert');"
                         "var counter = requireNative('counter');"
                         "assert.AssertTrue(counter.Get() == 0);"
                         "require('incrementsWhenEvaled');"
                         "assert.AssertTrue(counter.Get() == 1);"
                         "require('incrementsWhenEvaled');"
@@ skipping 144 matching lines @@
       env()->module_system());
   env()->RegisterModule(
       "test",
       "requireAsync('natives').then(function(natives) {"
       "  natives.requireAsync('ping').then(function(ping) {"
       "    return ping();"
       "  }).then(function(result) {"
       "    requireNative('assert').AssertTrue(result == 'pong');"
       "  });"
       "});");
-  scoped_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
+  std::unique_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
   other_env->RegisterModule("ping",
                             "define('ping', ['natives'], function(natives) {"
                             "  return function() {"
                             "    return 'pong';"
                             "  }"
                             "});");
   gin::ModuleRegistry::From(env()->context()->v8_context())
       ->AddBuiltinModule(
           env()->isolate(), "natives",
           other_env->module_system()->NewInstance());
@@ skipping 16 matching lines @@
       "test",
       "requireAsync('natives').then(function(natives) {"
       "  natives.requireAsync('ping').then(function(ping) {"
       "    return ping();"
       "  }).then(function(pong) {"
       "    return pong();"
       "  }).then(function(result) {"
       "    requireNative('assert').AssertTrue(result == 'done');"
       "  });"
       "});");
-  scoped_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
+  std::unique_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
   other_env->RegisterModule("ping",
                             "define('ping', ['natives'], function(natives) {"
                             "  return function() {"
                             "    return natives.requireAsync('pong');"
                             "  }"
                             "});");
   gin::ModuleRegistry::From(env()->context()->v8_context())
       ->AddBuiltinModule(
           env()->isolate(), "natives",
           other_env->module_system()->NewInstance());
@@ skipping 11 matching lines @@
   env()->RegisterModule("test",
                         "requireAsync('natives').then(function(natives) {"
                         "  var AssertTrue = requireNative('assert').AssertTrue;"
                         "  natives.requireAsync('foo').then(function() {"
                         "    AssertTrue(false);"
                         "  }).catch(function(error) {"
                         "    AssertTrue(error.message == "
                         "               'Extension view no longer exists');"
                         "  });"
                         "});");
-  scoped_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
+  std::unique_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
   gin::ModuleRegistry::From(env()->context()->v8_context())
       ->AddBuiltinModule(
           env()->isolate(), "natives",
           other_env->module_system()->NewInstance());
   other_env->ShutdownGin();
   env()->module_system()->Require("test");
   RunResolvedPromises();
 }
 
 TEST_F(ModuleSystemTest, TestRequireAsyncFromContextWithNoModuleSystem) {
   ModuleSystem::NativesEnabledScope natives_enabled_scope(
       env()->module_system());
   env()->RegisterModule("test",
                         "requireAsync('natives').then(function(natives) {"
                         "  requireNative('assert').AssertTrue("
                         "      natives.requireAsync('foo') === undefined);"
                         "});");
-  scoped_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
+  std::unique_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
   gin::ModuleRegistry::From(env()->context()->v8_context())
       ->AddBuiltinModule(
           env()->isolate(), "natives",
           other_env->module_system()->NewInstance());
   other_env->ShutdownModuleSystem();
   env()->module_system()->Require("test");
   RunResolvedPromises();
 }
 
 }  // namespace extensions