Global conversion of Pass()→std::move() on Linux

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>
 #include <vector>
 
 #include "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/modules/module_registry_observer.h"
 #include "gin/per_context_data.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/wrapper_info.h"
 #include "gin/runner.h"
@@ skipping 55 matching lines @@
   if (!args.GetNext(&factory))
     return args.ThrowError();
 
   scoped_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(), pending.Pass());
+  registry->AddPendingModule(args.isolate(), std::move(pending));
 }
 
 WrapperInfo g_wrapper_info = { kEmbedderNativeGin };
 
 Local<FunctionTemplate> GetDefineTemplate(Isolate* isolate) {
   PerIsolateData* data = PerIsolateData::From(isolate);
   Local<FunctionTemplate> templ = data->GetFunctionTemplate(
       &g_wrapper_info);
   if (templ.IsEmpty()) {
     templ = FunctionTemplate::New(isolate, Define);
@@ skipping 57 matching lines @@
 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) {
   const std::string pending_id = pending->id;
   const std::vector<std::string> pending_dependencies = pending->dependencies;
-  AttemptToLoad(isolate, pending.Pass());
+  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) {
   if (available_modules_.find(id) != available_modules_.end()) {
     // Should we call the callback asynchronously?
     callback.Run(GetModule(isolate, id));
@@ skipping 76 matching lines @@
 
   return RegisterModule(isolate, pending->id, module);
 }
 
 bool ModuleRegistry::AttemptToLoad(Isolate* isolate,
                                    scoped_ptr<PendingModule> pending) {
   if (!CheckDependencies(pending.get())) {
     pending_modules_.push_back(pending.release());
     return false;
   }
-  return Load(isolate, pending.Pass());
+  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]);
       pending_modules[i] = NULL;
-      if (AttemptToLoad(isolate, pending.Pass()))
+      if (AttemptToLoad(isolate, std::move(pending)))
         keep_trying = true;
     }
   }
 }
 
 }  // namespace gin