Consolidate search terms extraction and Instant process determination.

chrome/browser/search_engines/template_url.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/search_engines/template_url.h"
 
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 398 matching lines @@
   string16 result = display_url;
   ReplaceSubstringsAfterOffset(&result, 0, ASCIIToUTF16(kDisplaySearchTerms),
                                ASCIIToUTF16(kSearchTermsParameterFull));
   ReplaceSubstringsAfterOffset(
       &result, 0,
       ASCIIToUTF16(kDisplayUnescapedSearchTerms),
       ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull));
   return UTF16ToUTF8(result);
 }
 
-const std::string& TemplateURLRef::GetScheme() const {
-  ParseIfNecessary();
-  return scheme_;
-}
-
 const std::string& TemplateURLRef::GetHost() const {
   ParseIfNecessary();
   return host_;
 }
 
 const std::string& TemplateURLRef::GetPath() const {
   ParseIfNecessary();
   return path_;
 }
 
@@ skipping 83 matching lines @@
             NULL);
         return true;
       }
     }
   }
   return false;
 }
 
 void TemplateURLRef::InvalidateCachedValues() const {
   supports_replacements_ = valid_ = parsed_ = false;
-  scheme_.clear();
   host_.clear();
   path_.clear();
   search_term_key_.clear();
   replacements_.clear();
 }
 
 bool TemplateURLRef::ParseParameter(size_t start,
                                     size_t end,
                                     std::string* url,
                                     Replacements* replacements) const {
@@ skipping 146 matching lines @@
     const SearchTermsData& search_terms_data) const {
   std::string url_string(GetURL());
   ReplaceSubstringsAfterOffset(&url_string, 0,
                                kGoogleBaseURLParameterFull,
                                search_terms_data.GoogleBaseURLValue());
   ReplaceSubstringsAfterOffset(&url_string, 0,
                                kGoogleBaseSuggestURLParameterFull,
                                search_terms_data.GoogleBaseSuggestURLValue());
 
   search_term_key_.clear();
-  scheme_.clear();
   host_.clear();
   path_.clear();
   search_term_key_location_ = url_parse::Parsed::REF;
 
   GURL url(url_string);
   if (!url.is_valid())
     return;
 
   std::string query_key = FindSearchTermsKey(url.query());
   std::string ref_key = FindSearchTermsKey(url.ref());
   if (query_key.empty() == ref_key.empty())
     return;  // No key or multiple keys found.  We only handle having one key.
   search_term_key_ = query_key.empty() ? ref_key : query_key;
   search_term_key_location_ = query_key.empty() ?
       url_parse::Parsed::REF : url_parse::Parsed::QUERY;
-  scheme_ = url.scheme();
   host_ = url.host();
   path_ = url.path();
 }
 
 
 // TemplateURLData ------------------------------------------------------------
 
 TemplateURLData::TemplateURLData()
     : show_in_default_list(false),
       safe_for_autoreplace(false),
@@ skipping 150 matching lines @@
       if (key.is_nonempty() &&
           params[i].substr(key.begin, key.len) ==
               search_terms_replacement_key()) {
         return true;
       }
     }
   }
   return false;
 }
 
-bool TemplateURL::IsInstantURL(const GURL& url) {
-  // If the url matches the Instant ref, there's no need to
-  // check the replacement-key parameter, since we know this
-  // is instant.
-  // TODO(dhollowa): http://crbug.com/170390.  Consolidate Instant URL checks.
-  TemplateURLRef ref(this, TemplateURLRef::INSTANT);
-  GURL instant_url(ref.ReplaceSearchTerms(
-      TemplateURLRef::SearchTermsArgs(string16())));
-  if (instant_url.scheme() == url.scheme() &&
-      instant_url.host() == url.host() &&
-      instant_url.path() == url.path())
-    return true;
-
-  // Anything else requires the existence of the replacement-key.
-  if (!HasSearchTermsReplacementKey(url))
-    return false;
-
-  for (size_t i = 0; i < URLCount(); ++i) {
-    TemplateURLRef ref(this, i);
-    if (ref.GetScheme() == url.scheme() &&
-        ref.GetHost() == url.host() &&
-        ref.GetPath() == url.path())
-      return true;
-  }
-
-  return false;
-}
-
 void TemplateURL::CopyFrom(const TemplateURL& other) {
   if (this == &other)
     return;
 
   profile_ = other.profile_;
   data_ = other.data_;
   url_ref_.InvalidateCachedValues();
   suggestions_url_ref_.InvalidateCachedValues();
   instant_url_ref_.InvalidateCachedValues();
   SetPrepopulateId(other.data_.prepopulate_id);
@@ skipping 13 matching lines @@
 }
 
 void TemplateURL::ResetKeywordIfNecessary(bool force) {
   if (IsGoogleSearchURLWithReplaceableKeyword() || force) {
     DCHECK(!IsExtensionKeyword());
     GURL url(TemplateURLService::GenerateSearchURL(this));
     if (url.is_valid())
       data_.SetKeyword(TemplateURLService::GenerateKeyword(url));
   }
 }