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/template_url_service_factory.h"
 #include "chrome/browser/search_engines/ui_thread_search_terms_data.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
@@ skipping 359 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);
+  TemplateURLService* service =
+      TemplateURLServiceFactory::GetForProfile(profile_);

[blundell, 2014/06/26 09:00:00]

This class will eventually need to have the TemplateURLService passed in as
well. Is it worth it to just do that as part of this CL?

[Jun Mukai, 2014/06/26 21:01:19]

Agree, it would be better to pass TemplateURLService as a constructor argument.
But AutoCompleteController is created several places (6-7 classes create and own
its own controller, apart from tests), so doing it would make the change even
bigger.

Possibly preparing AutocompleteControllerFactory would be a better approach, and
that should be done in another CL. Let me create that CL first.

+  TemplateURL* template_url = match->GetTemplateURL(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",
@@ skipping 26 matching lines @@
   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());
 
+  TemplateURLService* template_url_service =
+      TemplateURLServiceFactory::GetForProfile(profile_);
+
   // 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 21 matching lines @@
 
   NotifyChanged(force_notify_default_match_changed || notify_default_match);
 }
 
 void AutocompleteController::UpdateAssociatedKeywords(
     AutocompleteResult* result) {
   if (!keyword_provider_)
     return;
 
   std::set<base::string16> keywords;
+  TemplateURLService* service =
+      TemplateURLServiceFactory::GetForProfile(profile_);
   for (ACMatches::iterator match(result->begin()); match != result->end();
        ++match) {
     base::string16 keyword(
-        match->GetSubstitutingExplicitlyInvokedKeyword(profile_));
+        match->GetSubstitutingExplicitlyInvokedKeyword(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);
     if (!keyword.empty() && !keywords.count(keyword)) {
       keywords.insert(keyword);
 
       if (!match->associated_keyword.get())
         match->associated_keyword.reset(new AutocompleteMatch(
             keyword_provider_->CreateVerbatimMatch(match->fill_into_edit,
                                                    keyword, input_)));
     } else {
       match->associated_keyword.reset();
     }
   }
 }
 
 void AutocompleteController::UpdateKeywordDescriptions(
     AutocompleteResult* result) {
   base::string16 last_keyword;
+  TemplateURLService* service =
+      TemplateURLServiceFactory::GetForProfile(profile_);
   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(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 30 matching lines @@
       count = 1;
     } else {
       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.
+  TemplateURLService* service =
+      TemplateURLServiceFactory::GetForProfile(profile_);
   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(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());
@@ skipping 37 matching lines @@
                         this, &AutocompleteController::ExpireCopiedEntries);
 }
 
 void AutocompleteController::StartStopTimer() {
   stop_timer_.Start(FROM_HERE,
                     stop_timer_duration_,
                     base::Bind(&AutocompleteController::Stop,
                                base::Unretained(this),
                                false));
 }