Replace FTS in the history_service with a brute force text search.

chrome/browser/history/query_parser.cc

 // Copyright (c) 2011 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 "chrome/browser/history/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/stl_util.h"
+#include "base/strings/utf_string_conversions.h"
 
 namespace {
 
+// Chinese/Japanese/Thai languages do not use spaces between words, so we
+// allow any Chinese/Japanese/Thai character to match as a word boundary.
+char kSafeRegexWordBoundary[] = "(\\b|[\\u0E00-\\u0E7F]|[\\u4E00-\\u9FFF])";
+
 // 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;
 }
 
 // Returns true if |mp2| intersects |mp1|. This is intended for use by
 // CoalesceMatchesFrom and isn't meant as a general intersection comparison
 // function.
@@ skipping 49 matching lines @@
  public:
   explicit QueryNodeWord(const string16& word);
   virtual ~QueryNodeWord();
 
   const string16& word() const { return word_; }
 
   void set_literal(bool literal) { literal_ = literal; }
 
   // QueryNode:
   virtual int AppendToSQLiteQuery(string16* query) const OVERRIDE;
+  virtual void AppendSQLiteRegexpQueries(
+      std::vector<string16>* queries) const OVERRIDE;
   virtual bool IsWord() const OVERRIDE;
   virtual bool Matches(const string16& word, bool exact) const OVERRIDE;
   virtual bool HasMatchIn(
       const std::vector<QueryWord>& words,
       Snippet::MatchPositions* match_positions) const OVERRIDE;
   virtual void AppendWords(std::vector<string16>* words) const OVERRIDE;
 
  private:
   string16 word_;
   bool literal_;
 
   DISALLOW_COPY_AND_ASSIGN(QueryNodeWord);
 };
 
 QueryNodeWord::QueryNodeWord(const string16& word)
     : word_(word),
       literal_(false) {}
 
 QueryNodeWord::~QueryNodeWord() {}
 
 int QueryNodeWord::AppendToSQLiteQuery(string16* query) const {
   query->append(word_);
 
   // Use prefix search if we're not literal and long enough.
   if (!literal_ && QueryParser::IsWordLongEnoughForPrefixSearch(word_))
     *query += L'*';
   return 1;
 }
 
+void QueryNodeWord::AppendSQLiteRegexpQueries(
+      std::vector<string16>* queries) const {
+  string16 query = ASCIIToUTF16("(?i).*");
+  query.append(ASCIIToUTF16(kSafeRegexWordBoundary));
+  query.append(word_);
+  if (!literal_ && QueryParser::IsWordLongEnoughForPrefixSearch(word_))
+    query.append(ASCIIToUTF16("\\w*"));
+  query.append(ASCIIToUTF16(kSafeRegexWordBoundary));
+  query.append(ASCIIToUTF16(".*"));
+
+  queries->push_back(query);
+}
+
 bool QueryNodeWord::IsWord() const {
   return true;
 }
 
 bool QueryNodeWord::Matches(const string16& word, bool exact) const {
   if (exact || !QueryParser::IsWordLongEnoughForPrefixSearch(word_))
     return word == word_;
   return word.size() >= word_.size() &&
          (word_.compare(0, word_.size(), word, 0, word_.size()) == 0);
 }
@@ skipping 27 matching lines @@
 
   QueryNodeVector* children() { return &children_; }
 
   void AddChild(QueryNode* node);
 
   // Remove empty subnodes left over from other parsing.
   void RemoveEmptySubnodes();
 
   // QueryNode:
   virtual int AppendToSQLiteQuery(string16* query) const OVERRIDE;
+  virtual void AppendSQLiteRegexpQueries(
+      std::vector<string16>* queries) const OVERRIDE;
   virtual bool IsWord() const OVERRIDE;
   virtual bool Matches(const string16& word, bool exact) const OVERRIDE;
   virtual bool HasMatchIn(
       const std::vector<QueryWord>& words,
       Snippet::MatchPositions* match_positions) const OVERRIDE;
   virtual void AppendWords(std::vector<string16>* words) const OVERRIDE;
 
  protected:
   int AppendChildrenToString(string16* query) const;
 
@@ skipping 25 matching lines @@
       --i;
       delete list_node;
     }
   }
 }
 
 int QueryNodeList::AppendToSQLiteQuery(string16* query) const {
   return AppendChildrenToString(query);
 }
 
+void QueryNodeList::AppendSQLiteRegexpQueries(
+      std::vector<string16>* queries) const {
+  for (QueryNodeVector::const_iterator node = children_.begin();
+       node != children_.end(); ++node) {
+    (*node)->AppendSQLiteRegexpQueries(queries);
+  }
+}
+
 bool QueryNodeList::IsWord() const {
   return false;
 }
 
 bool QueryNodeList::Matches(const string16& word, bool exact) const {
   NOTREACHED();
   return false;
 }
 
 bool QueryNodeList::HasMatchIn(const std::vector<QueryWord>& words,
@@ skipping 19 matching lines @@
 }
 
 // A QueryNodePhrase is a phrase query ("quoted").
 class QueryNodePhrase : public QueryNodeList {
  public:
   QueryNodePhrase();
   virtual ~QueryNodePhrase();
 
   // QueryNodeList:
   virtual int AppendToSQLiteQuery(string16* query) const OVERRIDE;
+  virtual void AppendSQLiteRegexpQueries(
+      std::vector<string16>* queries) const OVERRIDE;
   virtual bool HasMatchIn(
       const std::vector<QueryWord>& words,
       Snippet::MatchPositions* match_positions) const OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QueryNodePhrase);
 };
 
 QueryNodePhrase::QueryNodePhrase() {}
 
 QueryNodePhrase::~QueryNodePhrase() {}
 
 int QueryNodePhrase::AppendToSQLiteQuery(string16* query) const {
   query->push_back(L'"');
   int num_words = AppendChildrenToString(query);
   query->push_back(L'"');
   return num_words;
 }
 
+void QueryNodePhrase::AppendSQLiteRegexpQueries(
+      std::vector<string16>* queries) const {
+  string16 query = ASCIIToUTF16("(?i).*");
+  query.append(ASCIIToUTF16(kSafeRegexWordBoundary));
+  for (QueryNodeVector::const_iterator node = children_.begin();
+       node != children_.end(); ++node) {
+    (*node)->AppendToSQLiteQuery(&query);
+    if (node + 1 != children_.end()) {
+      // Match any non-word characters within phrase (enables url matching).
+      query.append(ASCIIToUTF16("\\W+"));
+    }
+  }
+  query.append(ASCIIToUTF16(kSafeRegexWordBoundary));
+  query.append(ASCIIToUTF16(".*"));
+  queries->push_back(query);
+}
+
 bool QueryNodePhrase::HasMatchIn(
     const std::vector<QueryWord>& words,
     Snippet::MatchPositions* match_positions) const {
   if (words.size() < children_.size())
     return false;
 
   for (size_t i = 0, max = words.size() - children_.size() + 1; i < max; ++i) {
     bool matched_all = true;
     for (size_t j = 0; j < children_.size(); ++j) {
       if (!children_[j]->Matches(words[i + j].word, true)) {
@@ skipping 26 matching lines @@
   return word.size() >= minimum_length;
 }
 
 int QueryParser::ParseQuery(const string16& query, string16* sqlite_query) {
   QueryNodeList root;
   if (!ParseQueryImpl(query, &root))
     return 0;
   return root.AppendToSQLiteQuery(sqlite_query);
 }
 
+void QueryParser::ParseQueryAsRegexps(const string16& query,
+                                      std::vector<string16>* sqlite_queries) {
+  QueryNodeList root;
+  if (!ParseQueryImpl(query, &root))
+    return;
+  return root.AppendSQLiteRegexpQueries(sqlite_queries);
+}
+
 void QueryParser::ParseQueryWords(const string16& query,
                                   std::vector<string16>* words) {
   QueryNodeList root;
   if (!ParseQueryImpl(query, &root))
     return;
   root.AppendWords(words);
 }
 
 void QueryParser::ParseQueryNodes(const string16& query,
                                   std::vector<QueryNode*>* nodes) {
@@ skipping 87 matching lines @@
     if (iter.IsWord()) {
       string16 word = iter.GetString();
       if (!word.empty()) {
         words->push_back(QueryWord());
         words->back().word = word;
         words->back().position = iter.prev();
       }
     }
   }
 }