Convert //tools to use std::unique_ptr

tools/gn/parser_unittest.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 <iostream>
 #include <sstream>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parser.h"
 #include "tools/gn/tokenizer.h"
 
 namespace {
 
 bool GetTokens(const InputFile* input, std::vector<Token>* result) {
   result->clear();
   Err err;
   *result = Tokenizer::Tokenize(input, &err);
   return !err.has_error();
 }
 
 void DoParserPrintTest(const char* input, const char* expected) {
   std::vector<Token> tokens;
   InputFile input_file(SourceFile("/test"));
   input_file.SetContents(input);
   ASSERT_TRUE(GetTokens(&input_file, &tokens));
 
   Err err;
-  scoped_ptr<ParseNode> result = Parser::Parse(tokens, &err);
+  std::unique_ptr<ParseNode> result = Parser::Parse(tokens, &err);
   if (!result)
     err.PrintToStdout();
   ASSERT_TRUE(result);
 
   std::ostringstream collector;
   result->Print(collector, 0);
 
   EXPECT_EQ(expected, collector.str());
 }
 
 void DoExpressionPrintTest(const char* input, const char* expected) {
   std::vector<Token> tokens;
   InputFile input_file(SourceFile("/test"));
   input_file.SetContents(input);
   ASSERT_TRUE(GetTokens(&input_file, &tokens));
 
   Err err;
-  scoped_ptr<ParseNode> result = Parser::ParseExpression(tokens, &err);
+  std::unique_ptr<ParseNode> result = Parser::ParseExpression(tokens, &err);
   ASSERT_TRUE(result);
 
   std::ostringstream collector;
   result->Print(collector, 0);
 
   EXPECT_EQ(expected, collector.str());
 }
 
 // Expects the tokenizer or parser to identify an error at the given line and
 // character.
 void DoParserErrorTest(const char* input, int err_line, int err_char) {
   InputFile input_file(SourceFile("/test"));
   input_file.SetContents(input);
 
   Err err;
   std::vector<Token> tokens = Tokenizer::Tokenize(&input_file, &err);
   if (!err.has_error()) {
-    scoped_ptr<ParseNode> result = Parser::Parse(tokens, &err);
+    std::unique_ptr<ParseNode> result = Parser::Parse(tokens, &err);
     ASSERT_FALSE(result);
     ASSERT_TRUE(err.has_error());
   }
 
   EXPECT_EQ(err_line, err.location().line_number());
   EXPECT_EQ(err_char, err.location().column_number());
 }
 
 // Expects the tokenizer or parser to identify an error at the given line and
 // character.
 void DoExpressionErrorTest(const char* input, int err_line, int err_char) {
   InputFile input_file(SourceFile("/test"));
   input_file.SetContents(input);
 
   Err err;
   std::vector<Token> tokens = Tokenizer::Tokenize(&input_file, &err);
   if (!err.has_error()) {
-    scoped_ptr<ParseNode> result = Parser::ParseExpression(tokens, &err);
+    std::unique_ptr<ParseNode> result = Parser::ParseExpression(tokens, &err);
     ASSERT_FALSE(result);
     ASSERT_TRUE(err.has_error());
   }
 
   EXPECT_EQ(err_line, err.location().line_number());
   EXPECT_EQ(err_char, err.location().column_number());
 }
 
 }  // namespace
 
@@ skipping 608 matching lines @@
 // freestanding block.
 TEST(Parser, StandaloneBlock) {
   DoParserErrorTest(
       "if (true) {\n"
       "}\n"
       "{\n"
       "  assert(false)\n"
       "}\n",
       3, 1);
 }