Reduces dependency from AutocompleteMatch to Profile.

chrome/browser/autocomplete/autocomplete_controller.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/autocomplete_controller.h"
 
 #include <set>
 #include <string>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/autocomplete_controller_delegate.h"
 #include "chrome/browser/autocomplete/bookmark_provider.h"
 #include "chrome/browser/autocomplete/builtin_provider.h"
 #include "chrome/browser/autocomplete/extension_app_provider.h"
 #include "chrome/browser/autocomplete/history_quick_provider.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/autocomplete/keyword_provider.h"
 #include "chrome/browser/autocomplete/search_provider.h"
 #include "chrome/browser/autocomplete/shortcuts_provider.h"
 #include "chrome/browser/autocomplete/zero_suggest_provider.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/omnibox/omnibox_field_trial.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
-#include "chrome/browser/search_engines/ui_thread_search_terms_data.h"
+#include "chrome/browser/search_engines/template_url_service.h"
 #include "components/search_engines/template_url.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // Converts the given match to a type (and possibly subtype) based on the AQS
 // specification. For more details, see
@@ skipping 125 matching lines @@
 bool AutocompleteMatchHasCustomDescription(const AutocompleteMatch& match) {
   return match.type == AutocompleteMatchType::SEARCH_SUGGEST_ENTITY ||
       match.type == AutocompleteMatchType::SEARCH_SUGGEST_PROFILE;
 }
 
 }  // namespace
 
 AutocompleteController::AutocompleteController(
     Profile* profile,
     AutocompleteControllerDelegate* delegate,
-    int provider_types)
+    int provider_types,
+    TemplateURLService* template_url_service)
     : delegate_(delegate),
       history_url_provider_(NULL),
       keyword_provider_(NULL),
       search_provider_(NULL),
       zero_suggest_provider_(NULL),
       stop_timer_duration_(OmniboxFieldTrial::StopTimerFieldTrialDuration()),
       done_(true),
       in_start_(false),
-      profile_(profile) {
+      template_url_service_(template_url_service) {
   provider_types &= ~OmniboxFieldTrial::GetDisabledProviderTypes();
   if (provider_types & AutocompleteProvider::TYPE_BOOKMARK)
     providers_.push_back(new BookmarkProvider(this, profile));
   if (provider_types & AutocompleteProvider::TYPE_BUILTIN)
     providers_.push_back(new BuiltinProvider(this, profile));
   if (provider_types & AutocompleteProvider::TYPE_EXTENSION_APP)
     providers_.push_back(new ExtensionAppProvider(this, profile));
   if (provider_types & AutocompleteProvider::TYPE_HISTORY_QUICK)
     providers_.push_back(new HistoryQuickProvider(this, profile));
   if (provider_types & AutocompleteProvider::TYPE_HISTORY_URL) {
@@ skipping 203 matching lines @@
 
 void AutocompleteController::ResetSession() {
   for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
        ++i)
     (*i)->ResetSession();
 }
 
 void AutocompleteController::UpdateMatchDestinationURL(
     base::TimeDelta query_formulation_time,
     AutocompleteMatch* match) const {
-  TemplateURL* template_url = match->GetTemplateURL(profile_, false);
+  TemplateURL* template_url = match->GetTemplateURL(
+      template_url_service_, false);
   if (!template_url || !match->search_terms_args.get() ||
       match->search_terms_args->assisted_query_stats.empty())
     return;
 
   // Append the query formulation time (time from when the user first typed a
   // character into the omnibox to when the user selected a query) and whether
   // a field trial has triggered to the AQS parameter.
   TemplateURLRef::SearchTermsArgs search_terms_args(*match->search_terms_args);
   search_terms_args.assisted_query_stats += base::StringPrintf(
       ".%" PRId64 "j%dj%d",
       query_formulation_time.InMilliseconds(),
       (search_provider_ &&
        search_provider_->field_trial_triggered_in_session()) ||
       (zero_suggest_provider_ &&
        zero_suggest_provider_->field_trial_triggered_in_session()),
       input_.current_page_classification());
   match->destination_url = GURL(template_url->url_ref().ReplaceSearchTerms(
-      search_terms_args, UIThreadSearchTermsData(profile_)));
+      search_terms_args, template_url_service_->search_terms_data()));
 }
 
 void AutocompleteController::UpdateResult(
     bool regenerate_result,
     bool force_notify_default_match_changed) {
   const bool last_default_was_valid = result_.default_match() != result_.end();
   // The following three variables are only set and used if
   // |last_default_was_valid|.
   base::string16 last_default_fill_into_edit, last_default_keyword,
       last_default_associated_keyword;
   if (last_default_was_valid) {
     last_default_fill_into_edit = result_.default_match()->fill_into_edit;
     last_default_keyword = result_.default_match()->keyword;
     if (result_.default_match()->associated_keyword != NULL)
       last_default_associated_keyword =
           result_.default_match()->associated_keyword->keyword;
   }
 
   if (regenerate_result)
     result_.Reset();
 
   AutocompleteResult last_result;
   last_result.Swap(&result_);
 
   for (ACProviders::const_iterator i(providers_.begin());
        i != providers_.end(); ++i)
     result_.AppendMatches((*i)->matches());
 
   // Sort the matches and trim to a small number of "best" matches.
-  result_.SortAndCull(input_, profile_);
+  result_.SortAndCull(input_, template_url_service_);
 
   // Need to validate before invoking CopyOldMatches as the old matches are not
   // valid against the current input.
 #ifndef NDEBUG
   result_.Validate();
 #endif
 
   if (!done_) {
     // This conditional needs to match the conditional in Start that invokes
     // StartExpireTimer.
-    result_.CopyOldMatches(input_, last_result, profile_);
+    result_.CopyOldMatches(input_, last_result, template_url_service_);
   }
 
   UpdateKeywordDescriptions(&result_);
   UpdateAssociatedKeywords(&result_);
   UpdateAssistedQueryStats(&result_);
 
   const bool default_is_valid = result_.default_match() != result_.end();
   base::string16 default_associated_keyword;
   if (default_is_valid &&
       (result_.default_match()->associated_keyword != NULL)) {
@@ skipping 24 matching lines @@
 
 void AutocompleteController::UpdateAssociatedKeywords(
     AutocompleteResult* result) {
   if (!keyword_provider_)
     return;
 
   std::set<base::string16> keywords;
   for (ACMatches::iterator match(result->begin()); match != result->end();
        ++match) {
     base::string16 keyword(
-        match->GetSubstitutingExplicitlyInvokedKeyword(profile_));
+        match->GetSubstitutingExplicitlyInvokedKeyword(template_url_service_));
     if (!keyword.empty()) {
       keywords.insert(keyword);
       continue;
     }
 
     // Only add the keyword if the match does not have a duplicate keyword with
     // a more relevant match.
     keyword = match->associated_keyword.get() ?
         match->associated_keyword->keyword :
         keyword_provider_->GetKeywordForText(match->fill_into_edit);
@@ skipping 15 matching lines @@
   base::string16 last_keyword;
   for (AutocompleteResult::iterator i(result->begin()); i != result->end();
        ++i) {
     if (AutocompleteMatch::IsSearchType(i->type)) {
       if (AutocompleteMatchHasCustomDescription(*i))
         continue;
       i->description.clear();
       i->description_class.clear();
       DCHECK(!i->keyword.empty());
       if (i->keyword != last_keyword) {
-        const TemplateURL* template_url = i->GetTemplateURL(profile_, false);
+        const TemplateURL* template_url =
+            i->GetTemplateURL(template_url_service_, false);
         if (template_url) {
           // For extension keywords, just make the description the extension
           // name -- don't assume that the normal search keyword description is
           // applicable.
           i->description = template_url->AdjustedShortNameForLocaleDirection();
           if (template_url->GetType() != TemplateURL::OMNIBOX_API_EXTENSION) {
             i->description = l10n_util::GetStringFUTF16(
                 IDS_AUTOCOMPLETE_SEARCH_DESCRIPTION, i->description);
           }
           i->description_class.push_back(
@@ skipping 32 matching lines @@
       count++;
     }
     last_type = type;
     last_subtype = subtype;
   }
   AppendAvailableAutocompletion(
       last_type, last_subtype, count, &autocompletions);
   // Go over all matches and set AQS if the match supports it.
   for (size_t index = 0; index < result->size(); ++index) {
     AutocompleteMatch* match = result->match_at(index);
-    const TemplateURL* template_url = match->GetTemplateURL(profile_, false);
+    const TemplateURL* template_url =
+        match->GetTemplateURL(template_url_service_, false);
     if (!template_url || !match->search_terms_args.get())
       continue;
     std::string selected_index;
     // Prevent trivial suggestions from getting credit for being selected.
     if (!IsTrivialAutocompletion(*match))
       selected_index = base::StringPrintf("%" PRIuS, index);
     match->search_terms_args->assisted_query_stats =
         base::StringPrintf("chrome.%s.%s",
                            selected_index.c_str(),
                            autocompletions.c_str());
     match->destination_url = GURL(template_url->url_ref().ReplaceSearchTerms(
-        *match->search_terms_args, UIThreadSearchTermsData(profile_)));
+        *match->search_terms_args, template_url_service_->search_terms_data()));
   }
 }
 
 void AutocompleteController::NotifyChanged(bool notify_default_match) {
   if (delegate_)
     delegate_->OnResultChanged(notify_default_match);
   if (done_) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY,
         content::Source<AutocompleteController>(this),
@@ skipping 25 matching lines @@
                         this, &AutocompleteController::ExpireCopiedEntries);
 }
 
 void AutocompleteController::StartStopTimer() {
   stop_timer_.Start(FROM_HERE,
                     stop_timer_duration_,
                     base::Bind(&AutocompleteController::Stop,
                                base::Unretained(this),
                                false));
 }