Reduces dependency from AutocompleteMatch to Profile.

chrome/browser/autocomplete/autocomplete_match.h

 // 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.
 
 #ifndef CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_MATCH_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_MATCH_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "chrome/common/autocomplete_match_type.h"
 #include "components/search_engines/template_url.h"
 #include "content/public/common/page_transition_types.h"
 #include "url/gurl.h"
 
 class AutocompleteProvider;
-class Profile;
 class TemplateURL;
+class TemplateURLService;
 
 namespace base {
 class Time;
 }  // namespace base
 
 const char kACMatchPropertyInputText[] = "input text";
 const char kACMatchPropertyContentsPrefix[] = "match contents prefix";
 const char kACMatchPropertyContentsStartIndex[] = "match contents start index";
 
 // AutocompleteMatch ----------------------------------------------------------
@@ skipping 136 matching lines @@
   // Convenience function to check if |type| is a special search suggest type -
   // like entity, personalized, profile or postfix.
   static bool IsSpecializedSearchType(Type type);
 
   // Copies the destination_url with "www." stripped off to
   // |stripped_destination_url| and also converts https protocol to
   // http.  These two conversions are merely to allow comparisons to
   // remove likely duplicates; these URLs are not used as actual
   // destination URLs.  This method is invoked internally by the
   // AutocompleteResult and does not normally need to be invoked.
-  // If |profile| is not NULL, it is used to get a template URL corresponding
-  // to this match.  The template is used to strip off query args other than
-  // the search terms themselves that would otherwise prevent from proper
-  // deduping.
-  void ComputeStrippedDestinationURL(Profile* profile);
+  // If |template_url_service| is not NULL, it is used to get a template URL
+  // corresponding to this match.  The template is used to strip off query args
+  // other than the search terms themselves that would otherwise prevent from
+  // proper deduping. |search_terms_data| is used to compute

[hashimoto, 2014/06/26 00:04:40]

I see no search_terms_data in this method.

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

Done.

+  void ComputeStrippedDestinationURL(TemplateURLService* template_url_service);
 
   // Gets data relevant to whether there should be any special keyword-related
   // UI shown for this match.  If this match represents a selected keyword, i.e.
   // the UI should be "in keyword mode", |keyword| will be set to the keyword
   // and |is_keyword_hint| will be set to false.  If this match has a non-NULL
   // |associated_keyword|, i.e. we should show a "Press [tab] to search ___"
   // hint and allow the user to toggle into keyword mode, |keyword| will be set
   // to the associated keyword and |is_keyword_hint| will be set to true.  Note
   // that only one of these states can be in effect at once.  In all other
   // cases, |keyword| will be cleared, even when our member variable |keyword|
   // is non-empty -- such as with non-substituting keywords or matches that
   // represent searches using the default search engine.  See also
   // GetSubstitutingExplicitlyInvokedKeyword().
-  void GetKeywordUIState(Profile* profile,
+  void GetKeywordUIState(TemplateURLService* template_url_service,
                          base::string16* keyword,
                          bool* is_keyword_hint) const;
 
   // Returns |keyword|, but only if it represents a substituting keyword that
   // the user has explicitly invoked.  If for example this match represents a
   // search with the default search engine (and the user didn't explicitly
   // invoke its keyword), this returns the empty string.  The result is that
   // this function returns a non-empty string in the same cases as when the UI
   // should show up as being "in keyword mode".
   base::string16 GetSubstitutingExplicitlyInvokedKeyword(
-      Profile* profile) const;
+      TemplateURLService* template_url_service) const;
 
   // Returns the TemplateURL associated with this match.  This may be NULL if
   // the match has no keyword OR if the keyword no longer corresponds to a valid
   // TemplateURL.  See comments on |keyword| below.
   // If |allow_fallback_to_destination_host| is true and the keyword does
   // not map to a valid TemplateURL, we'll then check for a TemplateURL that
   // corresponds to the destination_url's hostname.
-  TemplateURL* GetTemplateURL(Profile* profile,
+  TemplateURL* GetTemplateURL(TemplateURLService* template_url_service,
                               bool allow_fallback_to_destination_host) const;
 
   // Adds optional information to the |additional_info| dictionary.
   void RecordAdditionalInfo(const std::string& property,
                             const std::string& value);
   void RecordAdditionalInfo(const std::string& property, int value);
   void RecordAdditionalInfo(const std::string& property,
                             const base::Time& value);
 
   // Returns the value recorded for |property| in the |additional_info|
@@ skipping 139 matching lines @@
       const base::string16& text,
       const ACMatchClassifications& classifications) const;
 #endif
 };
 
 typedef AutocompleteMatch::ACMatchClassification ACMatchClassification;
 typedef std::vector<ACMatchClassification> ACMatchClassifications;
 typedef std::vector<AutocompleteMatch> ACMatches;
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_MATCH_H_