Convert //tools to use std::unique_ptr

tools/gn/input_conversion.cc

 // Copyright (c) 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 "tools/gn/input_conversion.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/string_split.h"
@@ skipping 20 matching lines @@
 // Sets the origin of the value and any nested values with the given node.
 Value ParseValueOrScope(const Settings* settings,
                         const std::string& input,
                         ValueOrScope what,
                         const ParseNode* origin,
                         Err* err) {
   // The memory for these will be kept around by the input file manager
   // so the origin parse nodes for the values will be preserved.
   InputFile* input_file;
   std::vector<Token>* tokens;
-  scoped_ptr<ParseNode>* parse_root_ptr;
+  std::unique_ptr<ParseNode>* parse_root_ptr;
   g_scheduler->input_file_manager()->AddDynamicInput(
       SourceFile(), &input_file, &tokens, &parse_root_ptr);
 
   input_file->SetContents(input);
   if (origin) {
     // This description will be the blame for any error messages caused by
     // script parsing or if a value is blamed. It will say
     // "Error at <...>:line:char" so here we try to make a string for <...>
     // that reads well in this context.
     input_file->set_friendly_name(
@@ skipping 15 matching lines @@
     *parse_root_ptr = Parser::Parse(*tokens, err);  // Will return a Block.
   if (err->has_error())
     return Value();
   ParseNode* parse_root = parse_root_ptr->get();  // For nicer syntax below.
 
   // It's valid for the result to be a null pointer, this just means that the
   // script returned nothing.
   if (!parse_root)
     return Value();
 
-  scoped_ptr<Scope> scope(new Scope(settings));
+  std::unique_ptr<Scope> scope(new Scope(settings));
   Value result = parse_root->Execute(scope.get(), err);
   if (err->has_error())
     return Value();
 
   // When we want the result as a scope, the result is actually the scope
   // we made, rather than the result of running the block (which will be empty).
   if (what == PARSE_SCOPE) {
     DCHECK(result.type() == Value::NONE);
     result = Value(origin, std::move(scope));
   }
@@ skipping 116 matching lines @@
                           const ParseNode* origin,
                           const Value& input_conversion_value,
                           Err* err) {
   if (input_conversion_value.type() == Value::NONE)
     return Value();  // Allow null inputs to mean discard the result.
   if (!input_conversion_value.VerifyTypeIs(Value::STRING, err))
     return Value();
   return DoConvertInputToValue(settings, input, origin, input_conversion_value,
                                input_conversion_value.string_value(), err);
 }