Use Instant suggested match type for Instant temporary text.

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/auto_reset.h"
@@ skipping 202 matching lines @@
 
 void SearchProvider::ClearInstantSuggestion() {
   default_provider_suggestion_ = InstantSuggestion();
   if (done_ || instant_finalized_)
     return;
   instant_finalized_ = true;
   UpdateMatches();
   listener_->OnProviderUpdate(true);
 }
 
+bool SearchProvider::GetSearchWhatYouTypedMatch(const string16& query,
+                                                const string16& original_query,
+                                                int relevance,
+                                                int accepted_suggestion,
+                                                bool is_keyword,
+                                                AutocompleteMatch* match) {
+  // Bail out now if we don't actually have a valid provider.
+  match->keyword = is_keyword ? providers_.keyword_provider() :

[Peter Kasting, 2013/04/12 00:29:01]

Nit: Wrap this like the old code (break after '?' and indent 4), since this
indenting doesn't really match anything in the style guide.

[sreeram, 2013/04/12 22:36:18]

Done.

+                                providers_.default_provider();
+  const TemplateURL* provider_url = match->GetTemplateURL(profile_, false);
+  if (provider_url == NULL)
+    return false;
+
+  match->provider = this;
+  match->relevance = relevance;
+  match->contents = query;
+  // We're dealing with the "default search" result which has no completion.
+  match->contents_class.push_back(
+      ACMatchClassification(0, ACMatchClassification::NONE));
+
+  if (is_keyword) {
+    match->fill_into_edit = match->keyword + char16(' ') + query;
+    match->transition = content::PAGE_TRANSITION_KEYWORD;
+    match->type = AutocompleteMatch::SEARCH_OTHER_ENGINE;
+  } else {
+    match->fill_into_edit = query;
+    match->transition = content::PAGE_TRANSITION_GENERATED;
+    match->type = AutocompleteMatch::SEARCH_WHAT_YOU_TYPED;
+  }
+
+  const TemplateURLRef& search_url = provider_url->url_ref();
+  DCHECK(search_url.SupportsReplacement());
+
+  match->search_terms_args.reset(new TemplateURLRef::SearchTermsArgs(query));
+  match->search_terms_args->original_query = original_query;
+  match->search_terms_args->accepted_suggestion = accepted_suggestion;
+
+  // This is the destination URL sans assisted query stats. This must be set so
+  // the AutocompleteController can properly de-dupe; the controller will
+  // eventually overwrite it before it reaches the user.
+  match->destination_url =
+      GURL(search_url.ReplaceSearchTerms(*match->search_terms_args.get()));
+
+  return true;
+}
+
 void SearchProvider::Start(const AutocompleteInput& input,
                            bool minimal_changes) {
   // Do our best to load the model as early as possible.  This will reduce
   // odds of having the model not ready when really needed (a non-empty input).
   TemplateURLService* model = providers_.template_url_service();
   DCHECK(model);
   model->Load();
 
   matches_.clear();
   field_trial_triggered_ = false;
@@ skipping 1085 matching lines @@
   return std::max(0, base_score - score_discount);
 }
 
 void SearchProvider::AddMatchToMap(const string16& query_string,
                                    const string16& input_text,
                                    int relevance,
                                    AutocompleteMatch::Type type,
                                    int accepted_suggestion,
                                    bool is_keyword,
                                    MatchMap* map) {
-  AutocompleteMatch match(this, relevance, false, type);
-  std::vector<size_t> content_param_offsets;
-  // Bail out now if we don't actually have a valid provider.
-  match.keyword = is_keyword ?
-      providers_.keyword_provider() : providers_.default_provider();
-  const TemplateURL* provider_url = match.GetTemplateURL(profile_, false);
-  if (provider_url == NULL)
+  AutocompleteMatch match;
+  // We start with a "what you typed" match (even if it's not the correct type)
+  // so that we get the benefit of common fields being filled in. We override
+  // fields below if the "what you typed" values for them are inappropriate.
+  if (!GetSearchWhatYouTypedMatch(query_string, input_text, relevance,
+                                  accepted_suggestion, is_keyword, &match))
     return;
 
-  match.contents.assign(query_string);
+  match.type = type;

[Peter Kasting, 2013/04/12 00:29:01]

Can we eliminate this, or the fill_into_edit mucking below, by moving code into
your new function?  For example, you could perhaps pass in the desired type as
an argument.  The function could maybe access |input_| if doing so makes sense
(see concerns in the header), and thus take care of all the rest of the
fill_into_edit stuff below.

[sreeram, 2013/04/12 22:36:18]

I don't think it makes sense for "SuggestExactInput" to be doing things that
clearly are because of non-exact input, so I've left the type and fill_into_edit
mucking as is.

[Peter Kasting, 2013/04/12 22:50:59]

Hmm.  Maybe I shouldn't have been so hasty to suggest calling this
SuggestExactInput().  Perhaps we should call it CreateSearchSuggestion and
generalize it slightly.

Even with exact input, some of the mucking makes sense -- prepending a '?' for
FORCED_QUERY or the keyword name in keyword mode (the latter of which the
function already does).  I'm mostly just trying to figure out what would result
in the least duplication of code/effort.  I don't have a violent opinion.

+
   // 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 != query_string) {
+    match.contents_class.clear();
     size_t input_position = match.contents.find(input_text);
     if (input_position == 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) {
         match.contents_class.push_back(
             ACMatchClassification(0, ACMatchClassification::NONE));
       }
       match.contents_class.push_back(
           ACMatchClassification(input_position, ACMatchClassification::DIM));
       size_t next_fragment_position = input_position + input_text.length();
       if (next_fragment_position < query_string.length()) {
         match.contents_class.push_back(
             ACMatchClassification(next_fragment_position,
                                   ACMatchClassification::NONE));
       }
     }
-  } else {
-    // Otherwise, we're dealing with the "default search" result which has no
-    // completion.
-    match.contents_class.push_back(
-        ACMatchClassification(0, ACMatchClassification::NONE));
   }
 
   // When the user forced a query, we need to make sure all the fill_into_edit
   // values preserve that property.  Otherwise, if the user starts editing a
   // suggestion, non-Search results will suddenly appear.
+  match.fill_into_edit.clear();
   if (input_.type() == AutocompleteInput::FORCED_QUERY)
     match.fill_into_edit.assign(ASCIIToUTF16("?"));
   if (is_keyword)
     match.fill_into_edit.append(match.keyword + char16(' '));
   if (!input_.prevent_inline_autocomplete() &&
       StartsWith(query_string, input_text, false)) {
     match.inline_autocomplete_offset =
         match.fill_into_edit.length() + input_text.length();
   }
   match.fill_into_edit.append(query_string);
 
-  const TemplateURLRef& search_url = provider_url->url_ref();
-  DCHECK(search_url.SupportsReplacement());
-  match.search_terms_args.reset(
-      new TemplateURLRef::SearchTermsArgs(query_string));
-  match.search_terms_args->original_query = input_text;
-  match.search_terms_args->accepted_suggestion = accepted_suggestion;
-  // This is the destination URL sans assisted query stats.  This must be set
-  // so the AutocompleteController can properly de-dupe; the controller will
-  // eventually overwrite it before it reaches the user.
-  match.destination_url =
-      GURL(search_url.ReplaceSearchTerms(*match.search_terms_args.get()));
-
-  // Search results don't look like URLs.
-  match.transition = is_keyword ?
-      content::PAGE_TRANSITION_KEYWORD : content::PAGE_TRANSITION_GENERATED;
-
   // Try to add |match| to |map|.  If a match for |query_string| is already in
   // |map|, replace it if |match| is more relevant.
   // NOTE: Keep this ToLower() call in sync with url_database.cc.
   const std::pair<MatchMap::iterator, bool> i = map->insert(
       std::pair<string16, AutocompleteMatch>(
           base::i18n::ToLower(query_string), match));
   // NOTE: We purposefully do a direct relevance comparison here instead of
   // using AutocompleteMatch::MoreRelevant(), so that we'll prefer "items added
   // first" rather than "items alphabetically first" when the scores are equal.
   // The only case this matters is when a user has results with the same score
@@ skipping 97 matching lines @@
     it->set_relevance(max_query_relevance);
   }
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when the timer isn't running, there are no suggest queries
   // pending, and we're not waiting on Instant.
   done_ = (!timer_.IsRunning() && (suggest_results_pending_ == 0) &&
            (instant_finalized_ || !chrome::IsInstantEnabled(profile_)));
 }