Introduce AutocompleteProviderDelegate

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/base64.h"
 #include "base/callback.h"
-#include "base/command_line.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_string_value_serializer.h"
-#include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/user_metrics.h"
-#include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/autocomplete/autocomplete_classifier.h"
-#include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
-#include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
-#include "chrome/browser/history/history_service.h"
-#include "chrome/browser/history/history_service_factory.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/common/pref_names.h"
-#include "components/google/core/browser/google_util.h"
 #include "components/history/core/browser/in_memory_database.h"
 #include "components/history/core/browser/keyword_search_term.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
+#include "components/omnibox/autocomplete_provider_delegate.h"
 #include "components/omnibox/autocomplete_provider_listener.h"
 #include "components/omnibox/autocomplete_result.h"
 #include "components/omnibox/keyword_provider.h"
 #include "components/omnibox/omnibox_field_trial.h"
 #include "components/omnibox/url_prefix.h"
 #include "components/search/search.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/variations/variations_http_header_provider.h"
 #include "grit/components_strings.h"
@@ skipping 78 matching lines @@
     return a.relevance() > b.relevance();
   }
 };
 
 
 // SearchProvider -------------------------------------------------------------
 
 // static
 int SearchProvider::kMinimumTimeBetweenSuggestQueriesMs = 100;
 
-SearchProvider::SearchProvider(AutocompleteProviderListener* listener,
-                               TemplateURLService* template_url_service,
-                               Profile* profile)
-    : BaseSearchProvider(template_url_service, profile,
+SearchProvider::SearchProvider(
+    AutocompleteProviderListener* listener,
+    TemplateURLService* template_url_service,
+    scoped_ptr<AutocompleteProviderDelegate> delegate)
+    : BaseSearchProvider(template_url_service, delegate.Pass(),
                          AutocompleteProvider::TYPE_SEARCH),
       listener_(listener),
       suggest_results_pending_(0),
       providers_(template_url_service),
       answers_cache_(1) {
 }
 
 // static
 std::string SearchProvider::GetSuggestMetadata(const AutocompleteMatch& match) {
   return match.GetAdditionalInfo(kSuggestMetadataKey);
@@ skipping 29 matching lines @@
                            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;
 
-  // Can't return search/suggest results for bogus input or without a profile.
-  if (!profile_ || (input.type() == metrics::OmniboxInputType::INVALID)) {
+  // Can't return search/suggest results for bogus input.
+  if (input.type() == metrics::OmniboxInputType::INVALID) {
     Stop(true);
     return;
   }
 
   keyword_input_ = input;
   const TemplateURL* keyword_provider =
       KeywordProvider::GetSubstitutingTemplateURLForInput(model,
                                                           &keyword_input_);
   if (keyword_provider == NULL)
     keyword_input_.Clear();
@@ skipping 137 matching lines @@
 }
 
 void SearchProvider::UpdateMatchContentsClass(
     const base::string16& input_text,
     SearchSuggestionParser::Results* results) {
   for (SearchSuggestionParser::SuggestResults::iterator sug_it =
            results->suggest_results.begin();
        sug_it != results->suggest_results.end(); ++sug_it) {
     sug_it->ClassifyMatchContents(false, input_text);
   }
-  const std::string languages(
-      profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
+  const std::string languages(delegate_->GetAcceptLanguages());
   for (SearchSuggestionParser::NavigationResults::iterator nav_it =
            results->navigation_results.begin();
        nav_it != results->navigation_results.end(); ++nav_it) {
     nav_it->CalculateAndClassifyMatchContents(false, input_text, languages);
   }
 }
 
 void SearchProvider::SortResults(bool is_keyword,
                                  SearchSuggestionParser::Results* results) {
   // Ignore suggested scores for non-keyword matches in keyword mode; if the
@@ skipping 120 matching lines @@
   if (minimal_changes)
     return;
 
   keyword_history_results_.clear();
   default_history_results_.clear();
 
   if (OmniboxFieldTrial::SearchHistoryDisable(
       input_.current_page_classification()))
     return;
 
-  HistoryService* const history_service =
-      HistoryServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
-  history::URLDatabase* url_db = history_service ?
-      history_service->InMemoryDatabase() : NULL;
+  history::URLDatabase* url_db = delegate_->InMemoryDatabase();
   if (!url_db)
     return;
 
   // 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
@@ skipping 60 matching lines @@
     return;
   }
   timer_.Start(FROM_HERE, next_suggest_time - now, this, &SearchProvider::Run);
 }
 
 bool SearchProvider::IsQuerySuitableForSuggest() const {
   // Don't run Suggest in incognito mode, if the engine doesn't support it, or
   // if the user has disabled it.
   const TemplateURL* default_url = providers_.GetDefaultProviderURL();
   const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
-  if (profile_->IsOffTheRecord() ||
+  if (delegate_->IsOffTheRecord() ||
       ((!default_url || default_url->suggestions_url().empty()) &&
        (!keyword_url || keyword_url->suggestions_url().empty())) ||
-      !profile_->GetPrefs()->GetBoolean(prefs::kSearchSuggestEnabled))
+      !delegate_->SearchSuggestEnabled())
     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() == metrics::OmniboxInputType::FORCED_QUERY)
     return true;
 
@@ skipping 100 matching lines @@
   }
   GURL suggest_url(template_url->suggestions_url_ref().ReplaceSearchTerms(
       search_term_args,
       providers_.template_url_service()->search_terms_data()));
   if (!suggest_url.is_valid())
     return NULL;
   // Send the current page URL if user setting and URL requirements are met and
   // the user is in the field trial.
   if (CanSendURL(current_page_url_, suggest_url, template_url,
                  input.current_page_classification(),
-                 template_url_service_->search_terms_data(), profile_) &&
+                 template_url_service_->search_terms_data(), delegate_.get()) &&
       OmniboxFieldTrial::InZeroSuggestAfterTypingFieldTrial()) {
     search_term_args.current_page_url = current_page_url_.spec();
     // Create the suggest URL again with the current page URL.
     suggest_url = GURL(template_url->suggestions_url_ref().ReplaceSearchTerms(
         search_term_args,
         providers_.template_url_service()->search_terms_data()));
   }
 
   suggest_results_pending_++;
   LogOmniboxSuggestRequest(REQUEST_SENT);
 
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(id, suggest_url, net::URLFetcher::GET, this);
-  fetcher->SetRequestContext(profile_->GetRequestContext());
+  fetcher->SetRequestContext(delegate_->GetRequestContext());
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
   // Add Chrome experiment state to the request headers.
   net::HttpRequestHeaders headers;
   variations::VariationsHttpHeaderProvider::GetInstance()->AppendHeaders(
-      fetcher->GetOriginalURL(), profile_->IsOffTheRecord(), false, &headers);
+      fetcher->GetOriginalURL(), delegate_->IsOffTheRecord(), false, &headers);
   fetcher->SetExtraRequestHeaders(headers.ToString());
   fetcher->Start();
   return fetcher;
 }
 
 void SearchProvider::ConvertResultsToAutocompleteMatches() {
   // Convert all the results to matches and add them to a map, so we can keep
   // the most relevant match for each result.
   base::TimeTicks start_time(base::TimeTicks::Now());
   MatchMap map;
@@ skipping 262 matching lines @@
   // NOTE: We don't check for autocompleting to URLs in the following cases:
   //  * When inline autocomplete is disabled, we won't be inline autocompleting
   //    this term, so we don't need to worry about confusion as much.  This
   //    also prevents calling Classify() again from inside the classifier
   //    (which will corrupt state and likely crash), since the classifier
   //    always disables inline autocomplete.
   //  * When the user has typed the whole string before as a query, then it's
   //    likely the user has no expectation that term should be interpreted as
   //    as a URL, so we need not do anything special to preserve user
   //    expectation.
-  AutocompleteClassifier* classifier =
-      AutocompleteClassifierFactory::GetForProfile(profile_);
   int last_relevance = 0;
   if (!base_prevent_inline_autocomplete && !found_what_you_typed_match &&
-      classifier && (scored_results.front().relevance() >= 1200)) {
+      scored_results.front().relevance() >= 1200) {
     AutocompleteMatch match;
-    classifier->Classify(scored_results.front().suggestion(), false, false,
-                         input_.current_page_classification(), &match, NULL);
+    delegate_->Classify(scored_results.front().suggestion(), false, false,
+                        input_.current_page_classification(), &match, NULL);
     // Demote this match that would normally be interpreted as a URL to have
     // the highest score a previously-issued search query could have when
     // scoring with the non-aggressive method.  A consequence of demoting
     // by revising |last_relevance| is that this match and all following
     // matches get demoted; the relative order of matches is preserved.
     // One could imagine demoting only those matches that might cause
     // confusion (which, by the way, might change the relative order of
     // matches.  We have decided to go with the simple demote-all approach
     // because selective demotion requires multiple Classify() calls and
     // such calls can be expensive (as expensive as running the whole
@@ skipping 149 matching lines @@
   // scheme.
   const URLPrefix* prefix =
       URLPrefix::BestURLPrefix(navigation.formatted_url(), input);
   size_t match_start = (prefix == NULL) ?
       navigation.formatted_url().find(input) : prefix->prefix.length();
   bool trim_http = !AutocompleteInput::HasHTTPScheme(input) &&
       (!prefix || (match_start != 0));
   const net::FormatUrlTypes format_types =
       net::kFormatUrlOmitAll & ~(trim_http ? 0 : net::kFormatUrlOmitHTTP);
 
-  const std::string languages(
-      profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
+  const std::string languages(delegate_->GetAcceptLanguages());
   size_t inline_autocomplete_offset = (prefix == NULL) ?
       base::string16::npos : (match_start + input.length());
   match.fill_into_edit +=
       AutocompleteInput::FormattedStringWithEquivalentMeaning(
           navigation.url(),
           net::FormatUrl(navigation.url(), languages, format_types,
                          net::UnescapeRule::SPACES, NULL, NULL,
                          &inline_autocomplete_offset),
-          ChromeAutocompleteSchemeClassifier(profile_));
+          delegate_->GetSchemeClassifier());
   // Preserve the forced query '?' prefix in |match.fill_into_edit|.
   // Otherwise, user edits to a suggestion would show non-Search results.
   if (input_.type() == metrics::OmniboxInputType::FORCED_QUERY) {
     match.fill_into_edit.insert(0, base::ASCIIToUTF16("?"));
     if (inline_autocomplete_offset != base::string16::npos)
       ++inline_autocomplete_offset;
   }
   if (inline_autocomplete_offset != base::string16::npos) {
     DCHECK(inline_autocomplete_offset <= match.fill_into_edit.length());
     match.inline_autocompletion =
@@ skipping 69 matching lines @@
       match->fill_into_edit.empty())
     return;
 
   // Valid answer encountered, cache it for further queries.
   answers_cache_.UpdateRecentAnswers(match->fill_into_edit, match->answer_type);
 }
 
 void SearchProvider::DoAnswersQuery(const AutocompleteInput& input) {
   prefetch_data_ = answers_cache_.GetTopAnswerEntry(input.text());
 }