Convert Pass()→std::move() in //tools

tools/gn/template.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 "tools/gn/template.h"
 
+#include <utility>
+
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/scope_per_file_provider.h"
 #include "tools/gn/value.h"
 
 Template::Template(const Scope* scope, const FunctionCallNode* def)
     : closure_(scope->MakeClosure()),
       definition_(def) {
 }
 
 Template::Template(scoped_ptr<Scope> scope, const FunctionCallNode* def)
-    : closure_(scope.Pass()),
-      definition_(def) {
-}
+    : closure_(std::move(scope)), definition_(def) {}
 
 Template::~Template() {
 }
 
 Value Template::Invoke(Scope* scope,
                        const FunctionCallNode* invocation,
                        const std::vector<Value>& args,
                        BlockNode* block,
                        Err* err) const {
   // Don't allow templates to be executed from imported files. Imports are for
@@ skipping 41 matching lines @@
   // setting it in the template scope (since the invocation scope may have
   // large lists of source files in it and could be expensive to copy).
   //
   // Scope.SetValue will copy the value which will in turn copy the scope, but
   // if we instead create a value and then set the scope on it, the copy can
   // be avoided.
   const char kInvoker[] = "invoker";
   template_scope.SetValue(kInvoker, Value(nullptr, scoped_ptr<Scope>()),
                           invocation);
   Value* invoker_value = template_scope.GetMutableValue(kInvoker, false);
-  invoker_value->SetScopeValue(invocation_scope.Pass());
+  invoker_value->SetScopeValue(std::move(invocation_scope));
   template_scope.set_source_dir(scope->GetSourceDir());
 
   const base::StringPiece target_name("target_name");
   template_scope.SetValue(target_name,
                           Value(invocation, args[0].string_value()),
                           invocation);
 
   // Actually run the template code.
   Value result =
       definition_->block()->Execute(&template_scope, err);
@@ skipping 21 matching lines @@
   // Check for unused variables in the template itself.
   if (!template_scope.CheckForUnusedVars(err))
     return Value();
 
   return result;
 }
 
 LocationRange Template::GetDefinitionRange() const {
   return definition_->GetRange();
 }