Remove stl_util's deletion function use from components/query_parser/.

components/query_parser/query_parser.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 "components/query_parser/query_parser.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 
 namespace query_parser {
 namespace {
 
 // Returns true if |mp1.first| is less than |mp2.first|. This is used to
 // sort match positions.
 int CompareMatchPosition(const Snippet::MatchPosition& mp1,
                          const Snippet::MatchPosition& mp2) {
   return mp1.first < mp2.first;
@@ skipping 124 matching lines @@
 void QueryNodeWord::AppendWords(std::vector<base::string16>* words) const {
   words->push_back(word_);
 }
 
 // A QueryNodeList has a collection of QueryNodes which are deleted in the end.
 class QueryNodeList : public QueryNode {
  public:
   QueryNodeList();
   ~QueryNodeList() override;
 
-  QueryNodeStarVector* children() { return &children_; }
+  QueryNodeVector* children() { return &children_; }
 
-  void AddChild(QueryNode* node);
+  void AddChild(std::unique_ptr<QueryNode> node);
 
   // Remove empty subnodes left over from other parsing.
   void RemoveEmptySubnodes();
 
   // QueryNode:
   int AppendToSQLiteQuery(base::string16* query) const override;
   bool IsWord() const override;
   bool Matches(const base::string16& word, bool exact) const override;
   bool HasMatchIn(const QueryWordVector& words,
                   Snippet::MatchPositions* match_positions) const override;
   bool HasMatchIn(const QueryWordVector& words) const override;
   void AppendWords(std::vector<base::string16>* words) const override;
 
  protected:
   int AppendChildrenToString(base::string16* query) const;
 
-  QueryNodeStarVector children_;
+  QueryNodeVector children_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QueryNodeList);
 };
 
 QueryNodeList::QueryNodeList() {}
 
 QueryNodeList::~QueryNodeList() {
-  base::STLDeleteElements(&children_);
 }
 
-void QueryNodeList::AddChild(QueryNode* node) {
-  children_.push_back(node);
+void QueryNodeList::AddChild(std::unique_ptr<QueryNode> node) {
+  children_.push_back(std::move(node));
 }
 
 void QueryNodeList::RemoveEmptySubnodes() {
   for (size_t i = 0; i < children_.size(); ++i) {
     if (children_[i]->IsWord())
       continue;
 
-    QueryNodeList* list_node = static_cast<QueryNodeList*>(children_[i]);
+    QueryNodeList* list_node = static_cast<QueryNodeList*>(children_[i].get());
     list_node->RemoveEmptySubnodes();
     if (list_node->children()->empty()) {
       children_.erase(children_.begin() + i);
       --i;
-      delete list_node;
     }
   }
 }
 
 int QueryNodeList::AppendToSQLiteQuery(base::string16* query) const {
   return AppendChildrenToString(query);
 }
 
 bool QueryNodeList::IsWord() const {
   return false;
@@ skipping 15 matching lines @@
   return false;
 }
 
 void QueryNodeList::AppendWords(std::vector<base::string16>* words) const {
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->AppendWords(words);
 }
 
 int QueryNodeList::AppendChildrenToString(base::string16* query) const {
   int num_words = 0;
-  for (QueryNodeStarVector::const_iterator node = children_.begin();
-       node != children_.end(); ++node) {
+  for (auto node = children_.begin(); node != children_.end(); ++node) {
     if (node != children_.begin())
       query->push_back(L' ');
     num_words += (*node)->AppendToSQLiteQuery(query);
   }
   return num_words;
 }
 
 // A QueryNodePhrase is a phrase query ("quoted").
 class QueryNodePhrase : public QueryNodeList {
  public:
@@ skipping 99 matching lines @@
                                   MatchingAlgorithm matching_algorithm,
                                   std::vector<base::string16>* words) {
   QueryNodeList root;
   if (!ParseQueryImpl(query, matching_algorithm, &root))
     return;
   root.AppendWords(words);
 }
 
 void QueryParser::ParseQueryNodes(const base::string16& query,
                                   MatchingAlgorithm matching_algorithm,
-                                  QueryNodeStarVector* nodes) {
+                                  QueryNodeVector* nodes) {
   QueryNodeList root;
   if (ParseQueryImpl(base::i18n::ToLower(query), matching_algorithm, &root))
     nodes->swap(*root.children());
 }
 
 bool QueryParser::DoesQueryMatch(const base::string16& text,
-                                 const QueryNodeStarVector& query_nodes,
+                                 const QueryNodeVector& query_nodes,
                                  Snippet::MatchPositions* match_positions) {
   if (query_nodes.empty())
     return false;
 
   QueryWordVector query_words;
   base::string16 lower_text = base::i18n::ToLower(text);
   ExtractQueryWords(lower_text, &query_words);
 
   if (query_words.empty())
     return false;
@@ skipping 10 matching lines @@
     // completely punt here.
     match_positions->clear();
   } else {
     SortAndCoalesceMatchPositions(&matches);
     match_positions->swap(matches);
   }
   return true;
 }
 
 bool QueryParser::DoesQueryMatch(const QueryWordVector& query_words,
-                                 const QueryNodeStarVector& query_nodes) {
+                                 const QueryNodeVector& query_nodes) {
   if (query_nodes.empty() || query_words.empty())
     return false;
 
   for (size_t i = 0; i < query_nodes.size(); ++i) {
     if (!query_nodes[i]->HasMatchIn(query_words))
       return false;
   }
   return true;
 }
 
 bool QueryParser::ParseQueryImpl(const base::string16& query,
                                  MatchingAlgorithm matching_algorithm,
                                  QueryNodeList* root) {
   base::i18n::BreakIterator iter(query, base::i18n::BreakIterator::BREAK_WORD);
   // TODO(evanm): support a locale here
   if (!iter.Init())
     return false;
 
   // To handle nesting, we maintain a stack of QueryNodeLists.
   // The last element (back) of the stack contains the current, deepest node.
   std::vector<QueryNodeList*> query_stack;
   query_stack.push_back(root);
 
   bool in_quotes = false;  // whether we're currently in a quoted phrase
   while (iter.Advance()) {
     // Just found a span between 'prev' (inclusive) and 'pos' (exclusive). It
     // is not necessarily a word, but could also be a sequence of punctuation
     // or whitespace.
     if (iter.IsWord()) {
-      QueryNodeWord* word_node = new QueryNodeWord(iter.GetString(),
-                                                   matching_algorithm);
+      std::unique_ptr<QueryNodeWord> word_node =
+          base::MakeUnique<QueryNodeWord>(iter.GetString(), matching_algorithm);
       if (in_quotes)
         word_node->set_literal(true);
-      query_stack.back()->AddChild(word_node);
+      query_stack.back()->AddChild(std::move(word_node));
     } else {  // Punctuation.
       if (IsQueryQuote(query[iter.prev()])) {
         if (!in_quotes) {
-          QueryNodeList* quotes_node = new QueryNodePhrase;
-          query_stack.back()->AddChild(quotes_node);
-          query_stack.push_back(quotes_node);
+          std::unique_ptr<QueryNodeList> quotes_node =
+              base::MakeUnique<QueryNodePhrase>();
+          QueryNodeList* quotes_node_ptr = quotes_node.get();
+          query_stack.back()->AddChild(std::move(quotes_node));
+          query_stack.push_back(quotes_node_ptr);
           in_quotes = true;
         } else {
           query_stack.pop_back();  // Stop adding to the quoted phrase.
           in_quotes = false;
         }
       }
     }
   }
 
   root->RemoveEmptySubnodes();
@@ skipping 26 matching lines @@
 void QueryParser::SortAndCoalesceMatchPositions(
     Snippet::MatchPositions* matches) {
   std::sort(matches->begin(), matches->end(), &CompareMatchPosition);
   // WARNING: we don't use iterator here as CoalesceMatchesFrom may remove
   // from matches.
   for (size_t i = 0; i < matches->size(); ++i)
     CoalesceMatchesFrom(i, matches);
 }
 
 }  // namespace query_parser