Adds QueryParser::ExtractQueryWords. For consistent this should...

chrome/browser/history/query_parser.cc

 // Copyright (c) 2006-2008 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 <algorithm>
 
 #include "chrome/browser/history/query_parser.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 79 matching lines @@
   virtual int AppendToSQLiteQuery(std::wstring* query) const;
   virtual bool IsWord() const { return true; }
 
   const std::wstring& word() const { return word_; }
   void set_literal(bool literal) { literal_ = literal; }
 
   virtual bool HasMatchIn(const std::vector<QueryWord>& words,
                           Snippet::MatchPositions* match_positions) const;
 
   virtual bool Matches(const std::wstring& word, bool exact) const;
+  virtual void AppendWords(std::vector<std::wstring>* words) const;
 
  private:
   std::wstring word_;
   bool literal_;
 };
 
 bool QueryNodeWord::HasMatchIn(const std::vector<QueryWord>& words,
                                Snippet::MatchPositions* match_positions) const {
   for (size_t i = 0; i < words.size(); ++i) {
     if (Matches(words[i].word, false)) {
       size_t match_start = words[i].position;
       match_positions->push_back(
           Snippet::MatchPosition(match_start,
                                  match_start + static_cast<int>(word_.size())));
       return true;
     }
   }
   return false;
 }
 
 bool QueryNodeWord::Matches(const std::wstring& word, bool exact) const {
   if (exact || !IsWordLongEnoughForPrefixSearch(word_))
     return word == word_;
   return word.size() >= word_.size() &&
          (word_.compare(0, word_.size(), word, 0, word_.size()) == 0);
 }
 
+void QueryNodeWord::AppendWords(std::vector<std::wstring>* words) const {
+  words->push_back(word_);
+}
+
 int QueryNodeWord::AppendToSQLiteQuery(std::wstring* query) const {
   query->append(word_);
 
   // Use prefix search if we're not literal and long enough.
   if (!literal_ && IsWordLongEnoughForPrefixSearch(word_))
     *query += L'*';
   return 1;
 }
 
 // A QueryNodeList has a collection of child QueryNodes
@@ skipping 18 matching lines @@
   // QueryNodeList is never used with Matches or HasMatchIn.
   virtual bool Matches(const std::wstring& word, bool exact) const {
     NOTREACHED();
     return false;
   }
   virtual bool HasMatchIn(const std::vector<QueryWord>& words,
                           Snippet::MatchPositions* match_positions) const {
     NOTREACHED();
     return false;
   }
+  virtual void AppendWords(std::vector<std::wstring>* words) const;
 
  protected:
   int AppendChildrenToString(std::wstring* query) const;
 
   QueryNodeVector children_;
 };
 
 QueryNodeList::~QueryNodeList() {
   for (QueryNodeVector::iterator node = children_.begin();
        node != children_.end(); ++node)
     delete *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]);
+    list_node->RemoveEmptySubnodes();
+    if (list_node->children()->empty()) {
+      children_.erase(children_.begin() + i);
+      --i;
+      delete list_node;
+    }
+  }
+}
+
+void QueryNodeList::AppendWords(std::vector<std::wstring>* words) const {
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->AppendWords(words);
+}
+
 int QueryNodeList::AppendChildrenToString(std::wstring* query) const {
   int num_words = 0;
   for (QueryNodeVector::const_iterator node = children_.begin();
        node != children_.end(); ++node) {
     if (node != children_.begin())
       query->push_back(L' ');
     num_words += (*node)->AppendToSQLiteQuery(query);
   }
   return num_words;
 }
@@ skipping 64 matching lines @@
   return root.AppendToSQLiteQuery(sqlite_query);
 }
 
 void QueryParser::ParseQuery(const std::wstring& query,
                              std::vector<QueryNode*>* nodes) {
   QueryNodeList root;
   if (ParseQueryImpl(l10n_util::ToLower(query), &root))
     nodes->swap(*root.children());
 }
 
+
+void QueryParser::ExtractQueryWords(const std::wstring& query,
+                                    std::vector<std::wstring>* words) {
+  QueryNodeList root;
+  if (!ParseQueryImpl(query, &root))
+    return;
+  root.AppendWords(words);  
+}
+
 bool QueryParser::DoesQueryMatch(const std::wstring& text,
                                  const std::vector<QueryNode*>& query_nodes,
                                  Snippet::MatchPositions* match_positions) {
   if (query_nodes.empty())
     return false;
 
   std::vector<QueryWord> query_words;
   ExtractQueryWords(l10n_util::ToLower(text), &query_words);
 
   if (query_words.empty())
@@ skipping 66 matching lines @@
     if (iter.IsWord()) {
       std::wstring word = iter.GetWord();
       if (!word.empty()) {
         words->push_back(QueryWord());
         words->back().word = word;
         words->back().position = iter.prev();
       }
     }
   }
 }
-
-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]);
-    list_node->RemoveEmptySubnodes();
-    if (list_node->children()->empty()) {
-      children_.erase(children_.begin() + i);
-      --i;
-      delete list_node;
-    }
-  }
-}