More misc. cleanups to minimize future refactoring diffs.

chrome/browser/autocomplete/search_provider.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/autocomplete/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/callback.h"
@@ skipping 44 matching lines @@
         found_word = true;
       }
     }
   }
   return false;
 }
 
 };
 
 
-// SearchProvider -------------------------------------------------------------
-
-// static
-const int SearchProvider::kDefaultProviderURLFetcherID = 1;
-// static
-const int SearchProvider::kKeywordProviderURLFetcherID = 2;
-// static
-bool SearchProvider::query_suggest_immediately_ = false;
+// SearchProvider::Providers --------------------------------------------------
 
 void SearchProvider::Providers::Set(const TemplateURL* default_provider,
                                     const TemplateURL* keyword_provider) {
   // TODO(pkasting): http://b/1162970  We shouldn't need to structure-copy
   // this. Nor should we need |default_provider_| and |keyword_provider_|
   // just to know whether the provider changed.
   default_provider_ = default_provider;
   if (default_provider)
     cached_default_provider_ = *default_provider;
   keyword_provider_ = keyword_provider;
   if (keyword_provider)
     cached_keyword_provider_ = *keyword_provider;
 }
 
+
+// SearchProvider -------------------------------------------------------------
+
+// static
+const int SearchProvider::kDefaultProviderURLFetcherID = 1;
+// static
+const int SearchProvider::kKeywordProviderURLFetcherID = 2;
+// static
+bool SearchProvider::query_suggest_immediately_ = false;
+
 SearchProvider::SearchProvider(ACProviderListener* listener, Profile* profile)
     : AutocompleteProvider(listener, profile, "Search"),
       suggest_results_pending_(0),
       have_suggest_results_(false),
       instant_finalized_(false) {
   // We use GetSuggestNumberOfGroups() as the group ID to mean "not in field
   // trial."  Field trial groups run from 0 to GetSuggestNumberOfGroups() - 1
   // (inclusive).
   int suggest_field_trial_group_number =
       AutocompleteFieldTrial::GetSuggestNumberOfGroups();
@@ skipping 138 matching lines @@
   bool operator()(const ScoredTerm& a, const ScoredTerm& b) {
     // Sort in descending relevance order.
     return a.second > b.second;
   }
 };
 
 void SearchProvider::Run() {
   // Start a new request with the current input.
   DCHECK(!done_);
   suggest_results_pending_ = 0;
+  if (providers_.valid_suggest_for_default_provider()) {
+    suggest_results_pending_++;
+    default_fetcher_.reset(CreateSuggestFetcher(kDefaultProviderURLFetcherID,
+        providers_.default_provider().suggestions_url_ref(), input_.text()));
+  }
   if (providers_.valid_suggest_for_keyword_provider()) {
     suggest_results_pending_++;
     keyword_fetcher_.reset(CreateSuggestFetcher(kKeywordProviderURLFetcherID,
-        providers_.keyword_provider(), keyword_input_text_));
-  }
-  if (providers_.valid_suggest_for_default_provider()) {
-    suggest_results_pending_++;
-    default_fetcher_.reset(CreateSuggestFetcher(kDefaultProviderURLFetcherID,
-        providers_.default_provider(), input_.text()));
+        providers_.keyword_provider().suggestions_url_ref(),
+        keyword_input_text_));
   }
   // We should only get here if we have a suggest url for the keyword or default
   // providers.
   DCHECK_GT(suggest_results_pending_, 0);
 }
 
 void SearchProvider::Stop() {
   StopSuggest();
   done_ = true;
   default_provider_suggest_text_.clear();
@@ skipping 64 matching lines @@
   // Request history for both the keyword and default provider.  We grab many
   // more matches than we'll ultimately clamp to so that if there are several
   // recent multi-word matches who scores are lowered (see
   // AddHistoryResultsToMap()), they won't crowd out older, higher-scoring
   // matches.  Note that this doesn't fix the problem entirely, but merely
   // limits it to cases with a very large number of such multi-word matches; for
   // now, this seems OK compared with the complexity of a real fix, which would
   // require multiple searches and tracking of "single- vs. multi-word" in the
   // database.
   int num_matches = kMaxMatches * 5;
+  if (providers_.valid_default_provider()) {
+    url_db->GetMostRecentKeywordSearchTerms(providers_.default_provider().id(),
+        input_.text(), num_matches, &default_history_results_);
+  }
   if (providers_.valid_keyword_provider()) {
     url_db->GetMostRecentKeywordSearchTerms(providers_.keyword_provider().id(),
         keyword_input_text_, num_matches, &keyword_history_results_);
   }
-  if (providers_.valid_default_provider()) {
-    url_db->GetMostRecentKeywordSearchTerms(providers_.default_provider().id(),
-        input_.text(), num_matches, &default_history_results_);
-  }
 }
 
 void SearchProvider::StartOrStopSuggestQuery(bool minimal_changes) {
   // Don't send any queries to the server until some time has elapsed after
   // the last keypress, to avoid flooding the server with requests we are
   // likely to end up throwing away anyway.
   const int kQueryDelayMs = 200;
 
   if (!IsQuerySuitableForSuggest()) {
     StopSuggest();
@@ skipping 23 matching lines @@
   suggest_results_pending_ = 1;
 
   // Kick off a timer that will start the URL fetch if it completes before
   // the user types another character.
   int delay = query_suggest_immediately_ ? 0 : kQueryDelayMs;
   timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(delay), this,
                &SearchProvider::Run);
 }
 
 bool SearchProvider::IsQuerySuitableForSuggest() const {
-  // Don't run Suggest in incognito mode, the engine doesn't support it, or
-  // the user has disabled it.
+  // Don't run Suggest in incognito mode, if the engine doesn't support it, or
+  // if the user has disabled it.
   if (profile_->IsOffTheRecord() ||
-      (!providers_.valid_suggest_for_keyword_provider() &&
-       !providers_.valid_suggest_for_default_provider()) ||
+      (!providers_.valid_suggest_for_default_provider() &&
+       !providers_.valid_suggest_for_keyword_provider()) ||
       !profile_->GetPrefs()->GetBoolean(prefs::kSearchSuggestEnabled))
     return false;
 
   // If the input type might be a URL, we take extra care so that private data
   // isn't sent to the server.
 
   // FORCED_QUERY means the user is explicitly asking us to search for this, so
   // we assume it isn't a URL and/or there isn't private data.
   if (input_.type() == AutocompleteInput::FORCED_QUERY)
     return true;
@@ skipping 42 matching lines @@
   default_fetcher_.reset();
   keyword_suggest_results_.clear();
   default_suggest_results_.clear();
   keyword_navigation_results_.clear();
   default_navigation_results_.clear();
   have_suggest_results_ = false;
 }
 
 content::URLFetcher* SearchProvider::CreateSuggestFetcher(
     int id,
-    const TemplateURL& provider,
+    const TemplateURLRef& suggestions_url,
     const string16& text) {
-  const TemplateURLRef& suggestions_url = provider.suggestions_url_ref();
   DCHECK(suggestions_url.SupportsReplacement());
   content::URLFetcher* fetcher = content::URLFetcher::Create(id,
       GURL(suggestions_url.ReplaceSearchTermsUsingProfile(
           profile_, text, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
           string16())),
       content::URLFetcher::GET, this);
   fetcher->SetRequestContext(profile_->GetRequestContext());
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
   fetcher->Start();
   return fetcher;
@@ skipping 362 matching lines @@
 void SearchProvider::AddMatchToMap(const string16& query_string,
                                    const string16& input_text,
                                    int relevance,
                                    AutocompleteMatch::Type type,
                                    int accepted_suggestion,
                                    bool is_keyword,
                                    bool prevent_inline_autocomplete,
                                    MatchMap* map) {
   AutocompleteMatch match(this, relevance, false, type);
   std::vector<size_t> content_param_offsets;
-  const TemplateURL& provider = is_keyword ? providers_.keyword_provider() :
-                                             providers_.default_provider();
+  const TemplateURL& provider = is_keyword ?
+      providers_.keyword_provider() : providers_.default_provider();
   match.template_url = &provider;
   match.contents.assign(query_string);
   // 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) {
     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
@@ skipping 108 matching lines @@
 
   return match;
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when there are no more suggest queries pending (this is set to 1
   // when the timer is started) and we're not waiting on instant.
   done_ = ((suggest_results_pending_ == 0) &&
            (instant_finalized_ || !InstantController::IsEnabled(profile_)));
 }