GN: Replace vector<ParseNode*> with vector<unique_ptr<ParseNode>> in parse_tree.h.

tools/gn/parse_tree.h

 // 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.
 
 #ifndef TOOLS_GN_PARSE_TREE_H_
 #define TOOLS_GN_PARSE_TREE_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 209 matching lines @@
   LocationRange GetRange() const override;
   Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
   void Print(std::ostream& out, int indent) const override;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(std::unique_ptr<EndNode> e) { end_ = std::move(e); }
   const EndNode* End() const { return end_.get(); }
 
-  const std::vector<ParseNode*>& statements() const { return statements_; }
+  const std::vector<std::unique_ptr<ParseNode>>& statements() const {
+    return statements_;
+  }
   void append_statement(std::unique_ptr<ParseNode> s) {
-    statements_.push_back(s.release());
+    statements_.push_back(std::move(s));
   }
 
  private:
   // Tokens corresponding to { and }, if any (may be NULL). The end is stored
   // in a custom parse node so that it can have comments hung off of it.
   Token begin_token_;
   std::unique_ptr<EndNode> end_;
 
-  // Owning pointers, use unique_ptr when we can use C++11.
-  std::vector<ParseNode*> statements_;
+  std::vector<std::unique_ptr<ParseNode>> statements_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockNode);
 };
 
 // ConditionNode ---------------------------------------------------------------
 
 class ConditionNode : public ParseNode {
  public:
   ConditionNode();
   ~ConditionNode() override;
@@ skipping 104 matching lines @@
   Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
   void Print(std::ostream& out, int indent) const override;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(std::unique_ptr<EndNode> e) { end_ = std::move(e); }
   const EndNode* End() const { return end_.get(); }
 
   void append_item(std::unique_ptr<ParseNode> s) {
-    contents_.push_back(s.release());
+    contents_.push_back(std::move(s));
   }
-  const std::vector<const ParseNode*>& contents() const { return contents_; }
+  const std::vector<std::unique_ptr<const ParseNode>>& contents() const {
+    return contents_;
+  }
 
   void SortAsStringsList();
   void SortAsDepsList();
 
   // During formatting, do we want this list to always be multliline? This is
   // used to make assignments to deps, sources, etc. always be multiline lists,
   // rather than collapsed to a single line when they're one element.
   bool prefer_multiline() const { return prefer_multiline_; }
   void set_prefer_multiline(bool prefer_multiline) {
     prefer_multiline_ = prefer_multiline;
@@ skipping 10 matching lines @@
  private:
   template <typename Comparator>
   void SortList(Comparator comparator);
 
   // Tokens corresponding to the [ and ]. The end token is stored in inside an
   // custom parse node so that it can have comments hung off of it.
   Token begin_token_;
   std::unique_ptr<EndNode> end_;
   bool prefer_multiline_;
 
-  // Owning pointers, use unique_ptr when we can use C++11.
-  std::vector<const ParseNode*> contents_;
+  std::vector<std::unique_ptr<const ParseNode>> contents_;
 
   DISALLOW_COPY_AND_ASSIGN(ListNode);
 };
 
 // LiteralNode -----------------------------------------------------------------
 
 class LiteralNode : public ParseNode {
  public:
   LiteralNode();
   explicit LiteralNode(const Token& token);
@@ skipping 99 matching lines @@
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(EndNode);
 };
 
 #endif  // TOOLS_GN_PARSE_TREE_H_