Reduces dependency from AutocompleteMatch to Profile.

chrome/browser/autocomplete/autocomplete_match.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_match.h"
 
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/search_engines/template_url_service.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/common/url_constants.h"
 #include "grit/theme_resources.h"
 
 namespace {
 
 bool IsTrivialClassification(const ACMatchClassifications& classifications) {
   return classifications.empty() ||
       ((classifications.size() == 1) &&
        (classifications.back().style == ACMatchClassification::NONE));
 }
 
@@ skipping 308 matching lines @@
 
 // static
 bool AutocompleteMatch::IsSpecializedSearchType(Type type) {
   return type == AutocompleteMatchType::SEARCH_SUGGEST_ENTITY ||
          type == AutocompleteMatchType::SEARCH_SUGGEST_INFINITE ||
          type == AutocompleteMatchType::SEARCH_SUGGEST_PERSONALIZED ||
          type == AutocompleteMatchType::SEARCH_SUGGEST_PROFILE ||
          type == AutocompleteMatchType::SEARCH_SUGGEST_ANSWER;
 }
 
-void AutocompleteMatch::ComputeStrippedDestinationURL(Profile* profile) {
+void AutocompleteMatch::ComputeStrippedDestinationURL(
+    TemplateURLService* template_url_service) {
   stripped_destination_url = destination_url;
   if (!stripped_destination_url.is_valid())
     return;
 
   // If the destination URL looks like it was generated from a TemplateURL,
   // remove all substitutions other than the search terms.  This allows us
   // to eliminate cases like past search URLs from history that differ only
   // by some obscure query param from each other or from the search/keyword
   // provider matches.
-  TemplateURL* template_url = GetTemplateURL(profile, true);
-  UIThreadSearchTermsData search_terms_data(profile);
+  TemplateURL* template_url = GetTemplateURL(template_url_service, true);
   if (template_url != NULL &&
-      template_url->SupportsReplacement(search_terms_data)) {
+      template_url->SupportsReplacement(
+          template_url_service->search_terms_data())) {
     base::string16 search_terms;
-    if (template_url->ExtractSearchTermsFromURL(stripped_destination_url,
-                                                search_terms_data,
-                                                &search_terms)) {
+    if (template_url->ExtractSearchTermsFromURL(
+            stripped_destination_url,
+            template_url_service->search_terms_data(),
+            &search_terms)) {
       stripped_destination_url =
           GURL(template_url->url_ref().ReplaceSearchTerms(
               TemplateURLRef::SearchTermsArgs(search_terms),
-              search_terms_data));
+              template_url_service->search_terms_data()));
     }
   }
 
   // |replacements| keeps all the substitions we're going to make to
   // from {destination_url} to {stripped_destination_url}.  |need_replacement|
   // is a helper variable that helps us keep track of whether we need
   // to apply the replacement.
   bool needs_replacement = false;
   GURL::Replacements replacements;
 
@@ skipping 12 matching lines @@
     replacements.SetScheme(url::kHttpScheme,
                            url::Component(0, strlen(url::kHttpScheme)));
     needs_replacement = true;
   }
 
   if (needs_replacement)
     stripped_destination_url = stripped_destination_url.ReplaceComponents(
         replacements);
 }
 
-void AutocompleteMatch::GetKeywordUIState(Profile* profile,
-                                          base::string16* keyword,
-                                          bool* is_keyword_hint) const {
+void AutocompleteMatch::GetKeywordUIState(
+    TemplateURLService* template_url_service,
+    base::string16* keyword,
+    bool* is_keyword_hint) const {
   *is_keyword_hint = associated_keyword.get() != NULL;
   keyword->assign(*is_keyword_hint ? associated_keyword->keyword :
-      GetSubstitutingExplicitlyInvokedKeyword(profile));
+      GetSubstitutingExplicitlyInvokedKeyword(template_url_service));
 }
 
 base::string16 AutocompleteMatch::GetSubstitutingExplicitlyInvokedKeyword(
-    Profile* profile) const {
+    TemplateURLService* template_url_service) const {
   if (transition != content::PAGE_TRANSITION_KEYWORD)
     return base::string16();
-  const TemplateURL* t_url = GetTemplateURL(profile, false);
+  const TemplateURL* t_url = GetTemplateURL(template_url_service, false);
   return (t_url &&
-          t_url->SupportsReplacement(UIThreadSearchTermsData(profile))) ?
+          t_url->SupportsReplacement(
+              template_url_service->search_terms_data())) ?
       keyword : base::string16();
 }
 
 TemplateURL* AutocompleteMatch::GetTemplateURL(
-    Profile* profile, bool allow_fallback_to_destination_host) const {
-  DCHECK(profile);
-  TemplateURLService* template_url_service =
-      TemplateURLServiceFactory::GetForProfile(profile);
+    TemplateURLService* template_url_service,
+    bool allow_fallback_to_destination_host) const {
   if (template_url_service == NULL)
     return NULL;
   TemplateURL* template_url = keyword.empty() ? NULL :
       template_url_service->GetTemplateURLForKeyword(keyword);
   if (template_url == NULL && allow_fallback_to_destination_host) {
     template_url = template_url_service->GetTemplateURLForHost(
         destination_url.host());
   }
   return template_url;
 }
@@ skipping 76 matching lines @@
         << " is unsorted in relation to last offset of " << last_offset
         << ". Provider: " << provider_name << ".";
     DCHECK_LT(i->offset, text.length())
         << " Classification of [" << i->offset << "," << text.length()
         << "] is out of bounds for \"" << text << "\". Provider: "
         << provider_name << ".";
     last_offset = i->offset;
   }
 }
 #endif