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

extensions/renderer/module_system_test.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_test.h"
 
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "extensions/common/extension_paths.h"
 #include "extensions/renderer/logging_native_handler.h"
 #include "extensions/renderer/object_backed_native_handler.h"
 #include "extensions/renderer/safe_builtins.h"
 #include "extensions/renderer/utils_native_handler.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace extensions {
@@ skipping 16 matching lines @@
             new v8::ExtensionConfiguration(static_cast<int>(names_.size()),
                                            names_.data())) {
     v8::RegisterExtension(safe_builtins_.get());
   }
 
   v8::ExtensionConfiguration* GetConfiguration() {
     return configuration_.get();
   }
 
  private:
-  scoped_ptr<v8::Extension> safe_builtins_;
+  std::unique_ptr<v8::Extension> safe_builtins_;
   std::vector<const char*> names_;
-  scoped_ptr<v8::ExtensionConfiguration> configuration_;
+  std::unique_ptr<v8::ExtensionConfiguration> configuration_;
 };
 
 base::LazyInstance<V8ExtensionConfigurator>::Leaky g_v8_extension_configurator =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // Native JS functions for doing asserts.
 class ModuleSystemTestEnvironment::AssertNatives
     : public ObjectBackedNativeHandler {
@@ skipping 68 matching lines @@
   context_.reset(new ScriptContext(context_holder_->context(),
                                    nullptr,  // WebFrame
                                    nullptr,  // Extension
                                    Feature::BLESSED_EXTENSION_CONTEXT,
                                    nullptr,  // Effective Extension
                                    Feature::BLESSED_EXTENSION_CONTEXT));
   context_->v8_context()->Enter();
   assert_natives_ = new AssertNatives(context_.get());
 
   {
-    scoped_ptr<ModuleSystem> module_system(
+    std::unique_ptr<ModuleSystem> module_system(
         new ModuleSystem(context_.get(), source_map_.get()));
     context_->set_module_system(std::move(module_system));
   }
   ModuleSystem* module_system = context_->module_system();
   module_system->RegisterNativeHandler(
-      "assert", scoped_ptr<NativeHandler>(assert_natives_));
+      "assert", std::unique_ptr<NativeHandler>(assert_natives_));
   module_system->RegisterNativeHandler(
       "logging",
-      scoped_ptr<NativeHandler>(new LoggingNativeHandler(context_.get())));
+      std::unique_ptr<NativeHandler>(new LoggingNativeHandler(context_.get())));
   module_system->RegisterNativeHandler(
       "utils",
-      scoped_ptr<NativeHandler>(new UtilsNativeHandler(context_.get())));
+      std::unique_ptr<NativeHandler>(new UtilsNativeHandler(context_.get())));
   module_system->SetExceptionHandlerForTest(
-      scoped_ptr<ModuleSystem::ExceptionHandler>(new FailsOnException));
+      std::unique_ptr<ModuleSystem::ExceptionHandler>(new FailsOnException));
 }
 
 ModuleSystemTestEnvironment::~ModuleSystemTestEnvironment() {
   if (context_->is_valid())
     ShutdownModuleSystem();
 }
 
 void ModuleSystemTestEnvironment::RegisterModule(const std::string& name,
                                                  const std::string& code) {
   source_map_->RegisterModule(name, code);
@@ skipping 69 matching lines @@
   // Run the GC until the heap size reaches a steady state to ensure that
   // all the garbage is collected.
   while (stats.used_heap_size() != old_heap_size) {
     old_heap_size = stats.used_heap_size();
     isolate_->RequestGarbageCollectionForTesting(
         v8::Isolate::kFullGarbageCollection);
     isolate_->GetHeapStatistics(&stats);
   }
 }
 
-scoped_ptr<ModuleSystemTestEnvironment> ModuleSystemTest::CreateEnvironment() {
-  return make_scoped_ptr(new ModuleSystemTestEnvironment(isolate_));
+std::unique_ptr<ModuleSystemTestEnvironment>
+ModuleSystemTest::CreateEnvironment() {
+  return base::WrapUnique(new ModuleSystemTestEnvironment(isolate_));
 }
 
 void ModuleSystemTest::ExpectNoAssertionsMade() {
   should_assertions_be_made_ = false;
 }
 
 void ModuleSystemTest::RunResolvedPromises() {
   v8::MicrotasksScope::PerformCheckpoint(isolate_);
 }
 
 }  // namespace extensions