Omnibox: Add Mid-Input Matching to HistoryQuick Provider

chrome/browser/history/url_index_private_data.cc

 // Copyright (c) 2012 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/url_index_private_data.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 #include <limits>
 #include <numeric>
+#include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/api/bookmarks/bookmark_service.h"
+#include "chrome/browser/autocomplete/autocomplete_field_trial.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/autocomplete/url_prefix.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/in_memory_url_index.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "net/base/net_util.h"
 
 #if defined(USE_SYSTEM_PROTOBUF)
@@ skipping 29 matching lines @@
 // Algorithm Functions ---------------------------------------------------------
 
 // Comparison function for sorting search terms by descending length.
 bool LengthGreater(const string16& string_a, const string16& string_b) {
   return string_a.length() > string_b.length();
 }
 
 // Public Functions ------------------------------------------------------------
 
 URLIndexPrivateData::URLIndexPrivateData()
-    : restored_cache_version_(0),
+    : use_cursor_position_(
+          AutocompleteFieldTrial::InHQPUseCursorPositionFieldTrial() &&
+          AutocompleteFieldTrial::
+              InHQPUseCursorPositionFieldTrialExperimentGroup()),
+      restored_cache_version_(0),
       saved_cache_version_(kCurrentCacheFileVersion),
       pre_filter_item_count_(0),
       post_filter_item_count_(0),
       post_scoring_item_count_(0) {
 }
 
 ScoredHistoryMatches URLIndexPrivateData::HistoryItemsForTerms(
-    const string16& search_string,
+    string16 search_string,
+    size_t cursor_position,
     BookmarkService* bookmark_service) {
+  // If we're allowed to use the cursor position, then if cursor
+  // position is set and useful (not at either end of the string),
+  // allow the search string to be broken at cursor position.  We do
+  // this by pretending there's a space where the cursor is.
+  // TODO(figure out highlighting).
+  if (use_cursor_position_ && (cursor_position != string16::npos) &&
+      (cursor_position < search_string.length()) &&
+      (cursor_position > 0)) {
+    search_string.insert(cursor_position, ASCIIToUTF16(" "));

[sky, 2013/02/06 04:59:43]

Is a space the right thing for all languages?

[Mark P, 2013/02/06 17:53:34]

Good question.

The answer is yes.  It's yes because of how the code below works--it first
breaks the string on character to non-character transitions and searches for
each substring (each word-like thing) separately.  This searching for word works
in all languages (the private_data data structures were built for this) and
words regardless of whether the breaks are at normal word boundaries or involve
searching for a few characters in the middle of a word.

The only funkiness I can imagine is if the cursor position is in the middle of a
character.  Is that possible in some IMEs?  Regardless, even if it's possible,
I'm not worried--the worst that can happen is that one gets weird or (more
likely) non-existent results when searching with a cursor in that position. 
(You'll need a match that involves the last half of the character followed by
the remaining text in the term.  This isn't likely to match anything.)

+  }
   pre_filter_item_count_ = 0;
   post_filter_item_count_ = 0;
   post_scoring_item_count_ = 0;
   // The search string we receive may contain escaped characters. For reducing
   // the index we need individual, lower-cased words, ignoring escapings. For
   // the final filtering we need whitespace separated substrings possibly
   // containing escaped characters.
   string16 lower_raw_string(base::i18n::ToLower(search_string));
   string16 lower_unescaped_string =
       net::UnescapeURLComponent(lower_raw_string,
@@ skipping 1061 matching lines @@
 }
 
 // static
 bool URLIndexPrivateData::URLSchemeIsWhitelisted(
     const GURL& gurl,
     const std::set<std::string>& whitelist) {
   return whitelist.find(gurl.scheme()) != whitelist.end();
 }
 
 }  // namespace history