Infinite Suggest for mac

chrome/browser/autocomplete/search_provider.cc

 // Copyright 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/autocomplete/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/callback.h"
@@ skipping 91 matching lines @@
   return false;
 }
 
 // Builds the match contents and classification for the contents, and updates
 // the given |AutocompleteMatch|.
 void SetAndClassifyMatchContents(const base::string16& query_string,
                                  const base::string16& input_text,
                                  const base::string16& match_contents,
                                  AutocompleteMatch* match) {
   match->contents = match_contents.empty() ? query_string : match_contents;
-
+  base::string16 lookup_text = input_text;
+  if (match->type == AutocompleteMatchType::SEARCH_SUGGEST_INFINITE) {
+    size_t content_index = query_string.rfind(match_contents);

[Scott Hess - ex-Googler, 2013/12/14 00:40:57]

I'm like 27% confident in this code (probably less).  Can match_contents appear
multiple times in query_string?

[Mark P, 2013/12/14 00:49:53]

FYI, I'm confident it can appear multiple times.

Actually, come to think of it, I think the string is supposed to end in
match_contents, right Anuj?

[Anuj, 2013/12/16 02:53:19]

Yes, match_contents can appear multiple times, but the query_string is supposed
to end in match_contents.

Given both the above conditions, what problem do you see with this code?

[Anuj, 2013/12/16 02:53:19]

Done.

[Scott Hess - ex-Googler, 2013/12/16 20:26:13]

I'll defer to Mark.  I was mostly concerned that you had explicitly considered
that case.

+    if (content_index != base::string16::npos) {
+      const base::string16 prefix = query_string.substr(0, content_index);
+      lookup_text = input_text.find(prefix) == 0 ?
+          input_text.substr(prefix.length()) : input_text;

[Scott Hess - ex-Googler, 2013/12/14 00:40:57]

std::string::find() will keep looking for |prefix| in |input_text| until it
finds it or there isn't room for it to be found.  input_text.compare(0,
prefix.length(), prefix) == 0 will only check the beginning.  In fact,
input_text.compare(0, content_index, query_string) == 0 should also work.

[Anuj, 2013/12/16 02:53:19]

Done.

+    }
+  }
   // We do intra-string highlighting for suggestions - the suggested segment
   // will be highlighted, e.g. for input_text = "you" the suggestion may be
   // "youtube", so we'll bold the "tube" section: you*tube*.
-  if (input_text != match_contents) {
-    size_t input_position = match->contents.find(input_text);
-    if (input_position == base::string16::npos) {
+  if (lookup_text != match_contents) {
+    size_t lookup_position = match->contents.find(lookup_text);
+    if (lookup_position == base::string16::npos) {
       // The input text is not a substring of the query string, e.g. input
       // text is "slasdot" and the query string is "slashdot", so we bold the
       // whole thing.
       match->contents_class.push_back(ACMatchClassification(
           0, ACMatchClassification::MATCH));
     } else {
       // TODO(beng): ACMatchClassification::MATCH now seems to just mean
       //             "bold" this. Consider modifying the terminology.
       // We don't iterate over the string here annotating all matches because
       // it looks odd to have every occurrence of a substring that may be as
       // short as a single character highlighted in a query suggestion result,
       // e.g. for input text "s" and query string "southwest airlines", it
       // looks odd if both the first and last s are highlighted.
-      if (input_position != 0) {
+      if (lookup_position != 0) {
         match->contents_class.push_back(ACMatchClassification(
             0, ACMatchClassification::MATCH));
       }
       match->contents_class.push_back(
-          ACMatchClassification(input_position, ACMatchClassification::NONE));
-      size_t next_fragment_position = input_position + input_text.length();
+          ACMatchClassification(lookup_position, ACMatchClassification::NONE));
+      size_t next_fragment_position = lookup_position + lookup_text.length();
       if (next_fragment_position < query_string.length()) {
         match->contents_class.push_back(ACMatchClassification(
             next_fragment_position, ACMatchClassification::MATCH));
       }
     }
   } else {
     // Otherwise, |match| is a verbatim (what-you-typed) match, either for the
     // default provider or a keyword search provider.
     match->contents_class.push_back(ACMatchClassification(
         0, ACMatchClassification::NONE));
@@ skipping 1877 matching lines @@
   if (!OmniboxFieldTrial::InZeroSuggestFieldTrial() ||
       service == NULL ||
       !service->IsSyncEnabledAndLoggedIn() ||
       !sync_prefs.GetPreferredDataTypes(syncer::UserTypes()).Has(
           syncer::PROXY_TABS) ||
       service->GetEncryptedDataTypes().Has(syncer::SESSIONS))
     return false;
 
   return true;
 }