Fix cursor position for default provider searches in keyword mode.

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 209 matching lines @@
 
   instant_finalized_ =
       (input.matches_requested() != AutocompleteInput::ALL_MATCHES);
 
   // Can't return search/suggest results for bogus input or without a profile.
   if (!profile_ || (input.type() == AutocompleteInput::INVALID)) {
     Stop(false);
     return;
   }
 
-  keyword_input_text_.clear();
+  keyword_input_ = input;
   const TemplateURL* keyword_provider =
-      KeywordProvider::GetSubstitutingTemplateURLForInput(profile_, input,
-                                                          &keyword_input_text_);
-  if (keyword_input_text_.empty())
+      KeywordProvider::GetSubstitutingTemplateURLForInput(model,
+                                                          &keyword_input_);
+  if (keyword_provider == NULL)
+    keyword_input_.Clear();
+  else if (keyword_input_.text().empty())
     keyword_provider = NULL;
 
   const TemplateURL* default_provider = model->GetDefaultSearchProvider();
   if (default_provider && !default_provider->SupportsReplacement())
     default_provider = NULL;
 
   if (keyword_provider == default_provider)
     default_provider = NULL;  // No use in querying the same provider twice.
 
   if (!default_provider && !keyword_provider) {
@@ skipping 78 matching lines @@
     return a.relevance() > b.relevance();
   }
 };
 
 void SearchProvider::Run() {
   // Start a new request with the current input.
   suggest_results_pending_ = 0;
   time_suggest_request_sent_ = base::TimeTicks::Now();
 
   default_fetcher_.reset(CreateSuggestFetcher(kDefaultProviderURLFetcherID,
-      providers_.GetDefaultProviderURL(), input_.text()));
+      providers_.GetDefaultProviderURL(), input_));
   keyword_fetcher_.reset(CreateSuggestFetcher(kKeywordProviderURLFetcherID,
-      providers_.GetKeywordProviderURL(), keyword_input_text_));
+      providers_.GetKeywordProviderURL(), keyword_input_));
 
   // Both the above can fail if the providers have been modified or deleted
   // since the query began.
   if (suggest_results_pending_ == 0) {
     UpdateDone();
     // We only need to update the listener if we're actually done.
     if (done_)
       listener_->OnProviderUpdate(false);
   }
 }
@@ skipping 121 matching lines @@
   // database.
   int num_matches = kMaxMatches * 5;
   const TemplateURL* default_url = providers_.GetDefaultProviderURL();
   if (default_url) {
     url_db->GetMostRecentKeywordSearchTerms(default_url->id(), input_.text(),
         num_matches, &default_history_results_);
   }
   const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
   if (keyword_url) {
     url_db->GetMostRecentKeywordSearchTerms(keyword_url->id(),
-        keyword_input_text_, num_matches, &keyword_history_results_);
+        keyword_input_.text(), num_matches, &keyword_history_results_);
   }
 }
 
 void SearchProvider::StartOrStopSuggestQuery(bool minimal_changes) {
   if (!IsQuerySuitableForSuggest()) {
     StopSuggest();
     ClearResults();
     return;
   }
 
@@ skipping 100 matching lines @@
   keyword_suggest_results_.clear();
   default_suggest_results_.clear();
   keyword_navigation_results_.clear();
   default_navigation_results_.clear();
   has_suggested_relevance_ = false;
   verbatim_relevance_ = -1;
   have_suggest_results_ = false;
 }
 
 void SearchProvider::RemoveStaleResults() {
-  // Keyword provider results should match |keyword_input_text_|, unless
+  // Keyword provider results should match |keyword_input_.text()|, unless
   // the input was just changed to non-keyword mode; in that case, compare
   // against |input_.text()|.
   const string16& keyword_input =
-      !keyword_input_text_.empty() ? keyword_input_text_ : input_.text();
+      !keyword_input_.text().empty() ? keyword_input_.text() : input_.text();
   RemoveStaleSuggestResults(&keyword_suggest_results_, keyword_input);
   RemoveStaleSuggestResults(&default_suggest_results_, input_.text());
   RemoveStaleNavigationResults(&keyword_navigation_results_, keyword_input);
   RemoveStaleNavigationResults(&default_navigation_results_, input_.text());
 }
 
 // static
 void SearchProvider::RemoveStaleSuggestResults(SuggestResults* list,
                                                const string16& input) {
   for (SuggestResults::iterator i = list->begin(); i < list->end();)
@@ skipping 30 matching lines @@
                                                         bool is_keyword) {
   for (size_t i = 0; i < list->size(); ++i) {
     (*list)[i].set_relevance(CalculateRelevanceForNavigation(is_keyword) +
                              (list->size() - i - 1));
   }
 }
 
 net::URLFetcher* SearchProvider::CreateSuggestFetcher(
     int id,
     const TemplateURL* template_url,
-    const string16& text) {
+    const AutocompleteInput& input) {
   if (!template_url || template_url->suggestions_url().empty())
     return NULL;
 
   // Bail if the suggestion URL is invalid with the given replacements.
-  TemplateURLRef::SearchTermsArgs search_term_args(text);
-  search_term_args.cursor_position = input_.cursor_position();
+  TemplateURLRef::SearchTermsArgs search_term_args(input.text());
+  search_term_args.cursor_position = input.cursor_position();
   GURL suggest_url(template_url->suggestions_url_ref().ReplaceSearchTerms(
       search_term_args));
   if (!suggest_url.is_valid())
     return NULL;
 
   suggest_results_pending_++;
   LogOmniboxSuggestRequest(REQUEST_SENT);
 
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(id, suggest_url, net::URLFetcher::GET, this);
   fetcher->SetRequestContext(profile_->GetRequestContext());
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
   // Add Chrome experiment state to the request headers.
   net::HttpRequestHeaders headers;
   chrome_variations::VariationsHttpHeaderProvider::GetInstance()->AppendHeaders(
       fetcher->GetOriginalURL(), profile_->IsOffTheRecord(), false, &headers);
   fetcher->SetExtraRequestHeaders(headers.ToString());
   fetcher->Start();
   return fetcher;
 }
 
 bool SearchProvider::ParseSuggestResults(Value* root_val, bool is_keyword) {
   // TODO(pkasting): Fix |have_suggest_results_|; see http://crbug.com/130631
   have_suggest_results_ = false;
 
   string16 query;
   ListValue* root_list = NULL;
   ListValue* results = NULL;
-  const string16& input_text = is_keyword ? keyword_input_text_ : input_.text();
+  const string16& input_text =
+      is_keyword ? keyword_input_.text() : input_.text();
   if (!root_val->GetAsList(&root_list) || !root_list->GetString(0, &query) ||
       (query != input_text) || !root_list->GetList(1, &results))
     return false;
 
   // 3rd element: Description list.
   ListValue* descriptions = NULL;
   root_list->GetList(2, &descriptions);
 
   // 4th element: Disregard the query URL list for now.
 
@@ skipping 244 matching lines @@
 
 void SearchProvider::AddHistoryResultsToMap(const HistoryResults& results,
                                             bool is_keyword,
                                             int did_not_accept_suggestion,
                                             MatchMap* map) {
   if (results.empty())
     return;
 
   bool prevent_inline_autocomplete = input_.prevent_inline_autocomplete() ||
       (input_.type() == AutocompleteInput::URL);
-  const string16& input_text = is_keyword ? keyword_input_text_ : input_.text();
+  const string16& input_text =
+      is_keyword ? keyword_input_.text() : input_.text();
   bool input_multiple_words = HasMultipleWords(input_text);
 
   SuggestResults scored_results;
   if (!prevent_inline_autocomplete && input_multiple_words) {
     // ScoreHistoryResults() allows autocompletion of multi-word, 1-visit
     // queries if the input also has multiple words.  But if we were already
     // autocompleting a multi-word, multi-visit query, and the current input is
     // still a prefix of it, then changing the autocompletion suddenly feels
     // wrong.  To detect this case, first score as if only one word has been
     // typed, then check for a best result that is an autocompleted, multi-word
@@ skipping 72 matching lines @@
       i->set_relevance(last_relevance - 1);
     last_relevance = i->relevance();
   }
 
   return scored_results;
 }
 
 void SearchProvider::AddSuggestResultsToMap(const SuggestResults& results,
                                             bool is_keyword,
                                             MatchMap* map) {
-  const string16& input_text = is_keyword ? keyword_input_text_ : input_.text();
+  const string16& input_text =
+      is_keyword ? keyword_input_.text() : input_.text();
   for (size_t i = 0; i < results.size(); ++i) {
     AddMatchToMap(results[i].suggestion(), input_text, results[i].relevance(),
                   AutocompleteMatch::SEARCH_SUGGEST, i, is_keyword, map);
   }
 }
 
 int SearchProvider::GetVerbatimRelevance() const {
   // Use the suggested verbatim relevance score if it is non-negative (valid),
   // if inline autocomplete isn't prevented (always show verbatim on backspace),
   // and if it won't suppress verbatim, leaving no default provider matches.
@@ skipping 177 matching lines @@
   // results sorted by recency, this means we'll pick the most recent such
   // result even if the precision of our relevance score is too low to
   // distinguish the two.
   if (!i.second && (match.relevance > i.first->second.relevance))
     i.first->second = match;
 }
 
 AutocompleteMatch SearchProvider::NavigationToMatch(
     const NavigationResult& navigation,
     bool is_keyword) {
-  const string16& input = is_keyword ? keyword_input_text_ : input_.text();
+  const string16& input = is_keyword ? keyword_input_.text() : input_.text();
   AutocompleteMatch match(this, navigation.relevance(), false,
                           AutocompleteMatch::NAVSUGGEST);
   match.destination_url = navigation.url();
 
   // First look for the user's input inside the fill_into_edit as it would be
   // without trimming the scheme, so we can find matches at the beginning of the
   // scheme.
   const string16 untrimmed_fill_into_edit(
       AutocompleteInput::FormattedStringWithEquivalentMeaning(navigation.url(),
           StringForURLDisplay(navigation.url(), true, false)));
@@ skipping 46 matching lines @@
 }
 
 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::BrowserInstantController::IsInstantEnabled(profile_) &&
              !chrome::search::IsInstantExtendedAPIEnabled(profile_))));
 }