Allow systematic prefix search in bookmarks.

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"
@@ skipping 48 matching lines @@
 }  // namespace
 
 // Inheritance structure:
 // Queries are represented as trees of QueryNodes.
 // QueryNodes are either a collection of subnodes (a QueryNodeList)
 // or a single word (a QueryNodeWord).
 
 // A QueryNodeWord is a single word in the query.
 class QueryNodeWord : public QueryNode {
  public:
-  explicit QueryNodeWord(const base::string16& word);
+  explicit QueryNodeWord(const base::string16& word,
+                         MatchingAlgorithm matching_algorithm);
   ~QueryNodeWord() override;
 
   const base::string16& word() const { return word_; }
 
+  bool literal() const { return literal_; };
   void set_literal(bool literal) { literal_ = literal; }
 
   // 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;
 
  private:
   base::string16 word_;
   bool literal_;
+  const MatchingAlgorithm matching_algorithm_;
 
   DISALLOW_COPY_AND_ASSIGN(QueryNodeWord);
 };
 
-QueryNodeWord::QueryNodeWord(const base::string16& word)
+QueryNodeWord::QueryNodeWord(const base::string16& word,
+                             MatchingAlgorithm matching_algorithm)
     : word_(word),
-      literal_(false) {}
+      literal_(false),
+      matching_algorithm_(matching_algorithm) {}
 
 QueryNodeWord::~QueryNodeWord() {}
 
 int QueryNodeWord::AppendToSQLiteQuery(base::string16* query) const {
   query->append(word_);
 
   // Use prefix search if we're not literal and long enough.
-  if (!literal_ && QueryParser::IsWordLongEnoughForPrefixSearch(word_))
+  if (!literal_ &&
+      QueryParser::IsWordLongEnoughForPrefixSearch(word_, matching_algorithm_))
     *query += L'*';
   return 1;
 }
 
 bool QueryNodeWord::IsWord() const {
   return true;
 }
 
 bool QueryNodeWord::Matches(const base::string16& word, bool exact) const {
-  if (exact || !QueryParser::IsWordLongEnoughForPrefixSearch(word_))
+  if (exact ||
+      !QueryParser::IsWordLongEnoughForPrefixSearch(word_, matching_algorithm_))
     return word == word_;
   return word.size() >= word_.size() &&
          (word_.compare(0, word_.size(), word, 0, word_.size()) == 0);
 }
 
 bool QueryNodeWord::HasMatchIn(const QueryWordVector& words,
                                Snippet::MatchPositions* match_positions) const {
   bool matched = false;
   for (size_t i = 0; i < words.size(); ++i) {
     if (Matches(words[i].word, false)) {
@@ skipping 185 matching lines @@
 
 bool QueryNodePhrase::HasMatchIn(const QueryWordVector& words) const {
   const QueryWord* first_word;
   const QueryWord* last_word;
   return MatchesAll(words, &first_word, &last_word);
 }
 
 QueryParser::QueryParser() {}
 
 // static
-bool QueryParser::IsWordLongEnoughForPrefixSearch(const base::string16& word) {
+bool QueryParser::IsWordLongEnoughForPrefixSearch(
+    const base::string16& word, MatchingAlgorithm matching_algorithm) {
+  if (matching_algorithm == MatchingAlgorithm::ALWAYS_PREFIX_SEARCH)
+    return true;
+
   DCHECK(!word.empty());
   size_t minimum_length = 3;
   // We intentionally exclude Hangul Jamos (both Conjoining and compatibility)
   // because they 'behave like' Latin letters. Moreover, we should
   // normalize the former before reaching here.
   if (0xAC00 <= word[0] && word[0] <= 0xD7A3)
     minimum_length = 2;
   return word.size() >= minimum_length;
 }
 
 int QueryParser::ParseQuery(const base::string16& query,
+                            MatchingAlgorithm matching_algorithm,
                             base::string16* sqlite_query) {
   QueryNodeList root;
-  if (!ParseQueryImpl(query, &root))
+  if (!ParseQueryImpl(query, matching_algorithm, &root))
     return 0;
   return root.AppendToSQLiteQuery(sqlite_query);
 }
 
 void QueryParser::ParseQueryWords(const base::string16& query,
+                                  MatchingAlgorithm matching_algorithm,
                                   std::vector<base::string16>* words) {
   QueryNodeList root;
-  if (!ParseQueryImpl(query, &root))
+  if (!ParseQueryImpl(query, matching_algorithm, &root))
     return;
   root.AppendWords(words);
 }
 
 void QueryParser::ParseQueryNodes(const base::string16& query,
+                                  MatchingAlgorithm matching_algorithm,
                                   QueryNodeStarVector* nodes) {
   QueryNodeList root;
-  if (ParseQueryImpl(base::i18n::ToLower(query), &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,
                                  Snippet::MatchPositions* match_positions) {
   if (query_nodes.empty())
     return false;
 
   QueryWordVector query_words;
@@ skipping 27 matching lines @@
     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());
+      QueryNodeWord* word_node = new QueryNodeWord(iter.GetString(),
+                                                   matching_algorithm);
       if (in_quotes)
         word_node->set_literal(true);
       query_stack.back()->AddChild(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);
           in_quotes = true;
@@ skipping 35 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