Convert //gin to use std::unique_ptr

gin/modules/module_registry.cc

 // Copyright 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 "gin/modules/module_registry.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <utility>
@@ skipping 38 matching lines @@
 PendingModule::~PendingModule() {
   factory.Reset();
 }
 
 namespace {
 
 // Key for base::SupportsUserData::Data.
 const char kModuleRegistryKey[] = "ModuleRegistry";
 
 struct ModuleRegistryData : public base::SupportsUserData::Data {
-  scoped_ptr<ModuleRegistry> registry;
+  std::unique_ptr<ModuleRegistry> registry;
 };
 
 void Define(const v8::FunctionCallbackInfo<Value>& info) {
   Arguments args(info);
 
   if (!info.Length())
     return args.ThrowTypeError("At least one argument is required.");
 
   std::string id;
   std::vector<std::string> dependencies;
   v8::Local<Value> factory;
 
   if (!args.PeekNext().IsEmpty() && args.PeekNext()->IsString())
     args.GetNext(&id);
   if (!args.PeekNext().IsEmpty() && args.PeekNext()->IsArray())
     args.GetNext(&dependencies);
   if (!args.GetNext(&factory))
     return args.ThrowError();
 
-  scoped_ptr<PendingModule> pending(new PendingModule);
+  std::unique_ptr<PendingModule> pending(new PendingModule);
   pending->id = id;
   pending->dependencies = dependencies;
   pending->factory.Reset(args.isolate(), factory);
 
   ModuleRegistry* registry =
       ModuleRegistry::From(args.isolate()->GetCurrentContext());
   registry->AddPendingModule(args.isolate(), std::move(pending));
 }
 
 WrapperInfo g_wrapper_info = { kEmbedderNativeGin };
@@ skipping 61 matching lines @@
   observer_list_.RemoveObserver(observer);
 }
 
 void ModuleRegistry::AddBuiltinModule(Isolate* isolate, const std::string& id,
                                       v8::Local<Value> module) {
   DCHECK(!id.empty());
   RegisterModule(isolate, id, module);
 }
 
 void ModuleRegistry::AddPendingModule(Isolate* isolate,
-                                      scoped_ptr<PendingModule> pending) {
+                                      std::unique_ptr<PendingModule> pending) {
   const std::string pending_id = pending->id;
   const std::vector<std::string> pending_dependencies = pending->dependencies;
   AttemptToLoad(isolate, std::move(pending));
   FOR_EACH_OBSERVER(ModuleRegistryObserver, observer_list_,
                     OnDidAddPendingModule(pending_id, pending_dependencies));
 }
 
 void ModuleRegistry::LoadModule(Isolate* isolate,
                                 const std::string& id,
                                 LoadModuleCallback callback) {
@@ skipping 48 matching lines @@
   for (size_t i = 0; i < len; ++i) {
     const std::string& dependency = pending->dependencies[i];
     if (available_modules_.count(dependency))
       continue;
     unsatisfied_dependencies_.insert(dependency);
     num_missing_dependencies++;
   }
   return num_missing_dependencies == 0;
 }
 
-bool ModuleRegistry::Load(Isolate* isolate, scoped_ptr<PendingModule> pending) {
+bool ModuleRegistry::Load(Isolate* isolate,
+                          std::unique_ptr<PendingModule> pending) {
   if (!pending->id.empty() && available_modules_.count(pending->id))
     return true;  // We've already loaded this module.
 
   uint32_t argc = static_cast<uint32_t>(pending->dependencies.size());
   std::vector<v8::Local<Value> > argv(argc);
   for (uint32_t i = 0; i < argc; ++i)
     argv[i] = GetModule(isolate, pending->dependencies[i]);
 
   v8::Local<Value> module = Local<Value>::New(isolate, pending->factory);
 
   v8::Local<Function> factory;
   if (ConvertFromV8(isolate, module, &factory)) {
     PerContextData* data = PerContextData::From(isolate->GetCurrentContext());
     Runner* runner = data->runner();
     module = runner->Call(factory, runner->global(), argc,
                           argv.empty() ? NULL : &argv.front());
     if (pending->id.empty())
       ConvertFromV8(isolate, factory->GetScriptOrigin().ResourceName(),
                     &pending->id);
   }
 
   return RegisterModule(isolate, pending->id, module);
 }
 
 bool ModuleRegistry::AttemptToLoad(Isolate* isolate,
-                                   scoped_ptr<PendingModule> pending) {
+                                   std::unique_ptr<PendingModule> pending) {
   if (!CheckDependencies(pending.get())) {
     pending_modules_.push_back(pending.release());
     return false;
   }
   return Load(isolate, std::move(pending));
 }
 
 v8::Local<v8::Value> ModuleRegistry::GetModule(v8::Isolate* isolate,
                                                 const std::string& id) {
   v8::Local<Object> modules = Local<Object>::New(isolate, modules_);
   v8::Local<String> key = StringToSymbol(isolate, id);
   DCHECK(modules->HasOwnProperty(isolate->GetCurrentContext(), key).FromJust());
   return modules->Get(isolate->GetCurrentContext(), key).ToLocalChecked();
 }
 
 void ModuleRegistry::AttemptToLoadMoreModules(Isolate* isolate) {
   bool keep_trying = true;
   while (keep_trying) {
     keep_trying = false;
     PendingModuleVector pending_modules;
     pending_modules.swap(pending_modules_);
     for (size_t i = 0; i < pending_modules.size(); ++i) {
-      scoped_ptr<PendingModule> pending(pending_modules[i]);
+      std::unique_ptr<PendingModule> pending(pending_modules[i]);
       pending_modules[i] = NULL;
       if (AttemptToLoad(isolate, std::move(pending)))
         keep_trying = true;
     }
   }
 }
 
 }  // namespace gin