Re-write many calls to WrapUnique() with MakeUnique()

tools/gn/parser.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/parser.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 444 matching lines @@
   return left;
 }
 
 std::unique_ptr<ParseNode> Parser::Block(const Token& token) {
   // This entrypoint into ParseBlock means it's part of an expression and we
   // always want the result.
   return ParseBlock(token, BlockNode::RETURNS_SCOPE);
 }
 
 std::unique_ptr<ParseNode> Parser::Literal(const Token& token) {
-  return base::WrapUnique(new LiteralNode(token));
+  return base::MakeUnique<LiteralNode>(token);
 }
 
 std::unique_ptr<ParseNode> Parser::Name(const Token& token) {
   return IdentifierOrCall(std::unique_ptr<ParseNode>(), token);
 }
 
 std::unique_ptr<ParseNode> Parser::BlockComment(const Token& token) {
   std::unique_ptr<BlockCommentNode> comment(new BlockCommentNode());
   comment->set_comment(token);
   return std::move(comment);
@@ skipping 46 matching lines @@
   binary_op->set_left(std::move(left));
   binary_op->set_right(std::move(right));
   return std::move(binary_op);
 }
 
 std::unique_ptr<ParseNode> Parser::IdentifierOrCall(
     std::unique_ptr<ParseNode> left,
     const Token& token) {
   std::unique_ptr<ListNode> list(new ListNode);
   list->set_begin_token(token);
-  list->set_end(base::WrapUnique(new EndNode(token)));
+  list->set_end(base::MakeUnique<EndNode>(token));
   std::unique_ptr<BlockNode> block;
   bool has_arg = false;
   if (LookAhead(Token::LEFT_PAREN)) {
     const Token& start_token = Consume();
     // Parsing a function call.
     has_arg = true;
     if (Match(Token::RIGHT_PAREN)) {
       // Nothing, just an empty call.
     } else {
       list = ParseList(start_token, Token::RIGHT_PAREN, false);
@@ skipping 119 matching lines @@
       // next item, so pretend we got one, if we're expecting one.
       just_got_comma = allow_trailing_comma;
     } else {
       just_got_comma = Match(Token::COMMA);
     }
   }
   if (just_got_comma && !allow_trailing_comma) {
     *err_ = Err(cur_token(), "Trailing comma");
     return std::unique_ptr<ListNode>();
   }
-  list->set_end(base::WrapUnique(new EndNode(cur_token())));
+  list->set_end(base::MakeUnique<EndNode>(cur_token()));
   return list;
 }
 
 std::unique_ptr<ParseNode> Parser::ParseFile() {
   std::unique_ptr<BlockNode> file(new BlockNode(BlockNode::DISCARDS_RESULT));
   for (;;) {
     if (at_end())
       break;
     std::unique_ptr<ParseNode> statement = ParseStatement();
     if (!statement)
@@ skipping 38 matching lines @@
 std::unique_ptr<BlockNode> Parser::ParseBlock(
     const Token& begin_brace,
     BlockNode::ResultMode result_mode) {
   if (has_error())
     return std::unique_ptr<BlockNode>();
   std::unique_ptr<BlockNode> block(new BlockNode(result_mode));
   block->set_begin_token(begin_brace);
 
   for (;;) {
     if (LookAhead(Token::RIGHT_BRACE)) {
-      block->set_end(base::WrapUnique(new EndNode(Consume())));
+      block->set_end(base::MakeUnique<EndNode>(Consume()));
       break;
     }
 
     std::unique_ptr<ParseNode> statement = ParseStatement();
     if (!statement)
       return std::unique_ptr<BlockNode>();
     block->append_statement(std::move(statement));
   }
   return block;
 }
@@ skipping 133 matching lines @@
         break;
       }
     }
 
     // Suffix comments were assigned in reverse, so if there were multiple on
     // the same node, they need to be reversed.
     if ((*i)->comments() && !(*i)->comments()->suffix().empty())
       const_cast<ParseNode*>(*i)->comments_mutable()->ReverseSuffix();
   }
 }