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 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() :
+                                providers_.default_provider();
+  const TemplateURL* provider_url = match->GetTemplateURL(profile_, false);
+  if (provider_url == NULL)
+    return false;
+
+  match->provider = this;
+  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, accepted_suggestion,
+                                  is_keyword, &match))
     return;
 
-  match.contents.assign(query_string);
+  match.relevance = relevance;
+  match.type = type;
+
   // 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_)));
 }